@devries-cameron20 / t3code Mirror · read-only
Fork 0

The best way to control Claude Code, Codex and more from any computer or phone

Mirrored from https://github.com/Camo67/t3code.git

Synced Nov 21, 04:45 UTC

main
ts 173 lines 5.47 KB
Raw
1 /**
2 * Git delta application (gitformat-pack §delta payload).
3 *
4 * A delta payload (after inflation) is:
5 *
6 * ```
7 * varint(base_size) varint(result_size) — plain 7-bit little-endian
8 * instructions...
9 * ```
10 *
11 * Instructions:
12 *
13 * - **Copy** (`1xxxxxxx`): bits 0–3 select which of 4 little-endian offset
14 * bytes follow; bits 4–6 which of 3 size bytes. Absent bytes are zero.
15 * **`size == 0` means `0x10000`** (the classic special case). Copies
16 * `size` bytes from `offset` in the base into the output.
17 * - **Insert** (`0xxxxxxx`, x ≠ 0): the low 7 bits are the count (1–127) of
18 * literal bytes that follow; append them.
19 * - `0x00` is reserved/invalid.
20 *
21 * Applying all instructions must produce exactly `result_size` bytes.
22 *
23 * Algorithm ported with attribution from isomorphic-git's `applyDelta`
24 * (MIT), cross-checked against ripgit's `apply_git_delta`.
25 */
26 import * as Effect from "effect/Effect";
27 import * as Schema from "effect/Schema";
28 import { decodeSizeVarint, ObjectParseError } from "./ObjectCodec.ts";
29
30 /**
31 * Error raised on malformed delta payloads: truncated headers/instructions,
32 * out-of-bounds copies, base size mismatch, or a result that does not match
33 * the declared `result_size`.
34 */
35 export class DeltaFormatError extends Schema.TaggedError<DeltaFormatError>()("DeltaFormatError", {
36 reason: Schema.String,
37 }) {}
38
39 /**
40 * The two size varints at the head of a delta payload, plus the offset of
41 * the first instruction byte.
42 */
43 export interface DeltaHeader {
44 readonly baseSize: number;
45 readonly resultSize: number;
46 /** Offset of the first instruction byte. */
47 readonly offset: number;
48 }
49
50 /**
51 * Reads the `base_size`/`result_size` varint header of a delta payload.
52 * Throws {@link DeltaFormatError} on truncation (pure function; use
53 * {@link applyDelta} for the Effect-typed path).
54 */
55 export const readDeltaHeader = (delta: Uint8Array): DeltaHeader => {
56 try {
57 const base = decodeSizeVarint(delta, 0);
58 const result = decodeSizeVarint(delta, base.next);
59 return {
60 baseSize: base.value,
61 resultSize: result.value,
62 offset: result.next,
63 };
64 } catch (error) {
65 throw Schema.is(ObjectParseError)(error)
66 ? DeltaFormatError.make({
67 reason: `truncated delta header: ${error.reason}`,
68 })
69 : error;
70 }
71 };
72
73 /**
74 * Applies a delta payload to its base, verifying the declared base size and
75 * that the output is exactly `result_size` bytes.
76 */
77 export const applyDelta = (
78 base: Uint8Array,
79 delta: Uint8Array,
80 ): Effect.Effect<Uint8Array, DeltaFormatError> =>
81 Effect.suspend(() => {
82 let header: DeltaHeader;
83 try {
84 header = readDeltaHeader(delta);
85 } catch (error) {
86 return Effect.fail(
87 Schema.is(DeltaFormatError)(error)
88 ? error
89 : DeltaFormatError.make({ reason: String(error) }),
90 );
91 }
92 if (header.baseSize !== base.length) {
93 return Effect.fail(
94 DeltaFormatError.make({
95 reason: `delta base size ${header.baseSize} != actual base ${base.length}`,
96 }),
97 );
98 }
99 const out = new Uint8Array(header.resultSize);
100 let outPos = 0;
101 let pos = header.offset;
102 while (pos < delta.length) {
103 const opcode = delta[pos]!;
104 pos += 1;
105 if (opcode === 0) {
106 return Effect.fail(DeltaFormatError.make({ reason: "reserved delta opcode 0x00" }));
107 }
108 if ((opcode & 0x80) !== 0) {
109 // copy instruction
110 let offset = 0;
111 let size = 0;
112 for (let bit = 0; bit < 4; bit++) {
113 if ((opcode & (1 << bit)) !== 0) {
114 if (pos >= delta.length) {
115 return Effect.fail(DeltaFormatError.make({ reason: "truncated copy offset" }));
116 }
117 offset += delta[pos]! * 2 ** (8 * bit);
118 pos += 1;
119 }
120 }
121 for (let bit = 0; bit < 3; bit++) {
122 if ((opcode & (1 << (4 + bit))) !== 0) {
123 if (pos >= delta.length) {
124 return Effect.fail(DeltaFormatError.make({ reason: "truncated copy size" }));
125 }
126 size += delta[pos]! * 2 ** (8 * bit);
127 pos += 1;
128 }
129 }
130 if (size === 0) size = 0x10000;
131 if (offset + size > base.length) {
132 return Effect.fail(
133 DeltaFormatError.make({
134 reason: `copy out of bounds: ${offset}+${size} > base ${base.length}`,
135 }),
136 );
137 }
138 if (outPos + size > out.length) {
139 return Effect.fail(
140 DeltaFormatError.make({
141 reason: `delta output overflows declared result size ${out.length}`,
142 }),
143 );
144 }
145 out.set(base.subarray(offset, offset + size), outPos);
146 outPos += size;
147 } else {
148 // insert instruction: opcode = literal byte count (1–127)
149 const size = opcode;
150 if (pos + size > delta.length) {
151 return Effect.fail(DeltaFormatError.make({ reason: "truncated insert data" }));
152 }
153 if (outPos + size > out.length) {
154 return Effect.fail(
155 DeltaFormatError.make({
156 reason: `delta output overflows declared result size ${out.length}`,
157 }),
158 );
159 }
160 out.set(delta.subarray(pos, pos + size), outPos);
161 outPos += size;
162 pos += size;
163 }
164 }
165 if (outPos !== out.length) {
166 return Effect.fail(
167 DeltaFormatError.make({
168 reason: `delta produced ${outPos} bytes, expected ${out.length}`,
169 }),
170 );
171 }
172 return Effect.succeed(out);
173 });