@flyingrobots/graft 0.9.0 → 0.10.1

package/dist/generated/graft-structural-history.codec.generated.js

@@ -3,7 +3,90 @@
 //
 // Wire layout is Wesley little-endian variable codec v0. Field order is SDL
 // declaration order. Enums encode their zero-based variant index as u32 LE.
-import { Writer, Reader, CodecError } from '../echo/codec-runtime.js';
+import { Writer as RuntimeWriter, Reader as RuntimeReader, CodecError as RuntimeCodecError } from '../echo/codec-runtime.js';
+function ok(value) {
+    return { ok: true, value };
+}
+function err(error) {
+    return { ok: false, error };
+}
+function codecErrorFromUnknown(error) {
+    if (error instanceof RuntimeCodecError) {
+        return error;
+    }
+    if (error instanceof Error) {
+        return new RuntimeCodecError(error.message);
+    }
+    return new RuntimeCodecError(String(error));
+}
+function decodeWithBoundary(b, read) {
+    try {
+        const r = new RuntimeReader(b);
+        const value = read(r);
+        if (r.remaining() > 0) {
+            return err(new RuntimeCodecError('trailing bytes after decode'));
+        }
+        return ok(value);
+    }
+    catch (error) {
+        return err(codecErrorFromUnknown(error));
+    }
+}
+// Graft's structural-history schema uses custom scalars before Wesley
+// exposes TypeScript scalar codec ports. Keep these shims deterministic and
+// local to the generated structural-history codec artifact.
+function _encHash(w, v) {
+    if (typeof v !== 'string') {
+        throw new RuntimeCodecError('Hash scalar must encode from a string');
+    }
+    w.writeString(v);
+}
+function _decHash(r) {
+    return r.readString();
+}
+function _encJson(w, v) {
+    const encoded = JSON.stringify(v);
+    if (encoded === undefined) {
+        throw new RuntimeCodecError('Json scalar must be JSON-serializable');
+    }
+    w.writeString(encoded);
+}
+function _decJson(r) {
+    try {
+        return JSON.parse(r.readString());
+    }
+    catch (error) {
+        throw codecErrorFromUnknown(error);
+    }
+}
+export function _encGitWarpImportBatch(w, v) {
+    w.writeString(v.importBatchId);
+    w.writeString(v.repositoryId);
+    w.writeString(v.sourceRef);
+    w.writeString(v.importedBasisId);
+    _encMigrationParityStatus(w, v.parity);
+    w.writeI32Le(v.importedReadingCount);
+    w.writeString(v.summary);
+}
+export function _decGitWarpImportBatch(r) {
+    return {
+        importBatchId: r.readString(),
+        repositoryId: r.readString(),
+        sourceRef: r.readString(),
+        importedBasisId: r.readString(),
+        parity: _decMigrationParityStatus(r),
+        importedReadingCount: r.readI32Le(),
+        summary: r.readString(),
+    };
+}
+export function _encGraftStructuralHistoryInvariants(w, v) {
+    w.writeOption(v._placeholder, (w, x) => w.writeBool(x));
+}
+export function _decGraftStructuralHistoryInvariants(r) {
+    return {
+        _placeholder: r.readOption((r) => r.readBool()),
+    };
+}
 export function _encMigrationParityStatus(w, v) {
     switch (v) {
         case 'NOT_CHECKED':
@@ -18,7 +101,7 @@ export function _encMigrationParityStatus(w, v) {
         case 'PARTIAL':
             w.writeU32Le(3);
             return;
-        default: throw new CodecError('invalid MigrationParityStatus variant: ' + String(v));
+        default: throw new RuntimeCodecError('invalid MigrationParityStatus variant: ' + String(v));
     }
 }
 export function _decMigrationParityStatus(r) {
@@ -28,16 +111,16 @@ export function _decMigrationParityStatus(r) {
         case 1: return 'MATCHED';
         case 2: return 'MISMATCHED';
         case 3: return 'PARTIAL';
-        default: throw new CodecError('invalid MigrationParityStatus discriminant: ' + String(d));
+        default: throw new RuntimeCodecError('invalid MigrationParityStatus discriminant: ' + String(d));
     }
 }
 export function encodeMigrationParityStatus(v) {
-    const w = new Writer();
+    const w = new RuntimeWriter();
     _encMigrationParityStatus(w, v);
     return w.finish();
 }
 export function decodeMigrationParityStatus(b) {
-    return _decMigrationParityStatus(new Reader(b));
+    return decodeWithBoundary(b, (r) => _decMigrationParityStatus(r));
 }
 export function _encRecordGitWarpImportBatchInput(w, v) {
     w.writeString(v.importBatchId);
@@ -70,7 +153,7 @@ export function _encSourceSpanEncoding(w, v) {
         case 'LINE_COLUMN':
             w.writeU32Le(2);
             return;
-        default: throw new CodecError('invalid SourceSpanEncoding variant: ' + String(v));
+        default: throw new RuntimeCodecError('invalid SourceSpanEncoding variant: ' + String(v));
     }
 }
 export function _decSourceSpanEncoding(r) {
@@ -79,16 +162,38 @@ export function _decSourceSpanEncoding(r) {
         case 0: return 'UTF8_BYTE_RANGE';
         case 1: return 'UTF16_CODE_UNIT_RANGE';
         case 2: return 'LINE_COLUMN';
-        default: throw new CodecError('invalid SourceSpanEncoding discriminant: ' + String(d));
+        default: throw new RuntimeCodecError('invalid SourceSpanEncoding discriminant: ' + String(d));
     }
 }
 export function encodeSourceSpanEncoding(v) {
-    const w = new Writer();
+    const w = new RuntimeWriter();
     _encSourceSpanEncoding(w, v);
     return w.finish();
 }
 export function decodeSourceSpanEncoding(b) {
-    return _decSourceSpanEncoding(new Reader(b));
+    return decodeWithBoundary(b, (r) => _decSourceSpanEncoding(r));
+}
+export function _encStructuralBasis(w, v) {
+    w.writeString(v.basisId);
+    w.writeString(v.repositoryId);
+    _encStructuralBasisKind(w, v.basisKind);
+    w.writeOption(v.commitId, (w, x) => w.writeString(x));
+    w.writeOption(v.refName, (w, x) => w.writeString(x));
+    w.writeOption(v.echoHeadId, (w, x) => w.writeString(x));
+    w.writeOption(v.importBatchId, (w, x) => w.writeString(x));
+    w.writeString(v.summary);
+}
+export function _decStructuralBasis(r) {
+    return {
+        basisId: r.readString(),
+        repositoryId: r.readString(),
+        basisKind: _decStructuralBasisKind(r),
+        commitId: r.readOption((r) => r.readString()),
+        refName: r.readOption((r) => r.readString()),
+        echoHeadId: r.readOption((r) => r.readString()),
+        importBatchId: r.readOption((r) => r.readString()),
+        summary: r.readString(),
+    };
 }
 export function _encStructuralBasisKind(w, v) {
     switch (v) {
@@ -107,7 +212,10 @@ export function _encStructuralBasisKind(w, v) {
         case 'IMPORT_BATCH':
             w.writeU32Le(4);
             return;
-        default: throw new CodecError('invalid StructuralBasisKind variant: ' + String(v));
+        case 'UNPINNED_COMMITTED':
+            w.writeU32Le(5);
+            return;
+        default: throw new RuntimeCodecError('invalid StructuralBasisKind variant: ' + String(v));
     }
 }
 export function _decStructuralBasisKind(r) {
@@ -118,16 +226,17 @@ export function _decStructuralBasisKind(r) {
         case 2: return 'ECHO_HEAD';
         case 3: return 'LIVE_FRONTIER';
         case 4: return 'IMPORT_BATCH';
-        default: throw new CodecError('invalid StructuralBasisKind discriminant: ' + String(d));
+        case 5: return 'UNPINNED_COMMITTED';
+        default: throw new RuntimeCodecError('invalid StructuralBasisKind discriminant: ' + String(d));
     }
 }
 export function encodeStructuralBasisKind(v) {
-    const w = new Writer();
+    const w = new RuntimeWriter();
     _encStructuralBasisKind(w, v);
     return w.finish();
 }
 export function decodeStructuralBasisKind(b) {
-    return _decStructuralBasisKind(new Reader(b));
+    return decodeWithBoundary(b, (r) => _decStructuralBasisKind(r));
 }
 export function _encStructuralEvidenceKind(w, v) {
     switch (v) {
@@ -140,7 +249,7 @@ export function _encStructuralEvidenceKind(w, v) {
         case 'FALLBACK_TRANSLATED':
             w.writeU32Le(2);
             return;
-        default: throw new CodecError('invalid StructuralEvidenceKind variant: ' + String(v));
+        default: throw new RuntimeCodecError('invalid StructuralEvidenceKind variant: ' + String(v));
     }
 }
 export function _decStructuralEvidenceKind(r) {
@@ -149,16 +258,104 @@ export function _decStructuralEvidenceKind(r) {
         case 0: return 'ECHO_NATIVE';
         case 1: return 'GIT_WARP_IMPORTED';
         case 2: return 'FALLBACK_TRANSLATED';
-        default: throw new CodecError('invalid StructuralEvidenceKind discriminant: ' + String(d));
+        default: throw new RuntimeCodecError('invalid StructuralEvidenceKind discriminant: ' + String(d));
     }
 }
 export function encodeStructuralEvidenceKind(v) {
-    const w = new Writer();
+    const w = new RuntimeWriter();
     _encStructuralEvidenceKind(w, v);
     return w.finish();
 }
 export function decodeStructuralEvidenceKind(b) {
-    return _decStructuralEvidenceKind(new Reader(b));
+    return decodeWithBoundary(b, (r) => _decStructuralEvidenceKind(r));
+}
+export function _encStructuralFileVersion(w, v) {
+    w.writeString(v.fileVersionId);
+    w.writeString(v.repositoryId);
+    w.writeString(v.basisId);
+    w.writeString(v.path);
+    _encHash(w, v.contentDigest);
+    w.writeOption(v.language, (w, x) => w.writeString(x));
+    w.writeString(v.summary);
+}
+export function _decStructuralFileVersion(r) {
+    return {
+        fileVersionId: r.readString(),
+        repositoryId: r.readString(),
+        basisId: r.readString(),
+        path: r.readString(),
+        contentDigest: _decHash(r),
+        language: r.readOption((r) => r.readString()),
+        summary: r.readString(),
+    };
+}
+export function _encStructuralParserRun(w, v) {
+    w.writeString(v.parserRunId);
+    w.writeString(v.fileVersionId);
+    w.writeString(v.parserName);
+    w.writeOption(v.parserVersion, (w, x) => w.writeString(x));
+    w.writeI32Le(v.diagnosticCount);
+    w.writeString(v.summary);
+}
+export function _decStructuralParserRun(r) {
+    return {
+        parserRunId: r.readString(),
+        fileVersionId: r.readString(),
+        parserName: r.readString(),
+        parserVersion: r.readOption((r) => r.readString()),
+        diagnosticCount: r.readI32Le(),
+        summary: r.readString(),
+    };
+}
+export function _encStructuralReading(w, v) {
+    w.writeString(v.readingId);
+    w.writeString(v.repositoryId);
+    w.writeString(v.basisId);
+    w.writeString(v.evidenceId);
+    _encStructuralReadingKind(w, v.readingKind);
+    _encStructuralReadingFreshness(w, v.freshness);
+    _encStructuralReadingResidualPosture(w, v.residualPosture);
+    _encHash(w, v.payloadDigest);
+    w.writeOption(v.payloadJson, (w, x) => _encJson(w, x));
+    w.writeString(v.summary);
+}
+export function _decStructuralReading(r) {
+    return {
+        readingId: r.readString(),
+        repositoryId: r.readString(),
+        basisId: r.readString(),
+        evidenceId: r.readString(),
+        readingKind: _decStructuralReadingKind(r),
+        freshness: _decStructuralReadingFreshness(r),
+        residualPosture: _decStructuralReadingResidualPosture(r),
+        payloadDigest: _decHash(r),
+        payloadJson: r.readOption((r) => _decJson(r)),
+        summary: r.readString(),
+    };
+}
+export function _encStructuralReadingEvidence(w, v) {
+    w.writeString(v.evidenceId);
+    _encStructuralEvidenceKind(w, v.evidenceKind);
+    _encStructuralSubstrateKind(w, v.substrate);
+    w.writeString(v.basisId);
+    w.writeOption(v.sourceRef, (w, x) => w.writeString(x));
+    w.writeOption(v.migrationBatchId, (w, x) => w.writeString(x));
+    w.writeBool(v.nativeContinuumWitness);
+    _encMigrationParityStatus(w, v.parity);
+    w.writeString(v.summary);
+}
+export function _decStructuralReadingEvidence(r) {
+    return {
+        evidenceId: r.readString(),
+        evidenceKind: _decStructuralEvidenceKind(r),
+        substrate: _decStructuralSubstrateKind(r),
+        basisId: r.readString(),
+        sourceRef: r.readOption((r) => r.readString()),
+        migrationBatchId: r.readOption((r) => r.readString()),
+        nativeContinuumWitness: r.readBool(),
+        parity: _decMigrationParityStatus(r),
+        summary: r.readString(),
+    };
 }
 export function _encStructuralReadingFreshness(w, v) {
     switch (v) {
@@ -177,7 +374,7 @@ export function _encStructuralReadingFreshness(w, v) {
         case 'LIVE_FRONTIER':
             w.writeU32Le(4);
             return;
-        default: throw new CodecError('invalid StructuralReadingFreshness variant: ' + String(v));
+        default: throw new RuntimeCodecError('invalid StructuralReadingFreshness variant: ' + String(v));
     }
 }
 export function _decStructuralReadingFreshness(r) {
@@ -188,16 +385,16 @@ export function _decStructuralReadingFreshness(r) {
         case 2: return 'INCOMPARABLE';
         case 3: return 'UNKNOWN';
         case 4: return 'LIVE_FRONTIER';
-        default: throw new CodecError('invalid StructuralReadingFreshness discriminant: ' + String(d));
+        default: throw new RuntimeCodecError('invalid StructuralReadingFreshness discriminant: ' + String(d));
     }
 }
 export function encodeStructuralReadingFreshness(v) {
-    const w = new Writer();
+    const w = new RuntimeWriter();
     _encStructuralReadingFreshness(w, v);
     return w.finish();
 }
 export function decodeStructuralReadingFreshness(b) {
-    return _decStructuralReadingFreshness(new Reader(b));
+    return decodeWithBoundary(b, (r) => _decStructuralReadingFreshness(r));
 }
 export function _encStructuralReadingKind(w, v) {
     switch (v) {
@@ -222,7 +419,7 @@ export function _encStructuralReadingKind(w, v) {
         case 'PRECISION_CODE_LOOKUP':
             w.writeU32Le(6);
             return;
-        default: throw new CodecError('invalid StructuralReadingKind variant: ' + String(v));
+        default: throw new RuntimeCodecError('invalid StructuralReadingKind variant: ' + String(v));
     }
 }
 export function _decStructuralReadingKind(r) {
@@ -235,16 +432,16 @@ export function _decStructuralReadingKind(r) {
         case 4: return 'STRUCTURAL_LOG';
         case 5: return 'STRUCTURAL_CHURN';
         case 6: return 'PRECISION_CODE_LOOKUP';
-        default: throw new CodecError('invalid StructuralReadingKind discriminant: ' + String(d));
+        default: throw new RuntimeCodecError('invalid StructuralReadingKind discriminant: ' + String(d));
     }
 }
 export function encodeStructuralReadingKind(v) {
-    const w = new Writer();
+    const w = new RuntimeWriter();
     _encStructuralReadingKind(w, v);
     return w.finish();
 }
 export function decodeStructuralReadingKind(b) {
-    return _decStructuralReadingKind(new Reader(b));
+    return decodeWithBoundary(b, (r) => _decStructuralReadingKind(r));
 }
 export function _encStructuralReadingResidualPosture(w, v) {
     switch (v) {
@@ -272,7 +469,7 @@ export function _encStructuralReadingResidualPosture(w, v) {
         case 'DEGRADED':
             w.writeU32Le(7);
             return;
-        default: throw new CodecError('invalid StructuralReadingResidualPosture variant: ' + String(v));
+        default: throw new RuntimeCodecError('invalid StructuralReadingResidualPosture variant: ' + String(v));
     }
 }
 export function _decStructuralReadingResidualPosture(r) {
@@ -286,16 +483,52 @@ export function _decStructuralReadingResidualPosture(r) {
         case 5: return 'UNAVAILABLE';
         case 6: return 'OBSTRUCTED';
         case 7: return 'DEGRADED';
-        default: throw new CodecError('invalid StructuralReadingResidualPosture discriminant: ' + String(d));
+        default: throw new RuntimeCodecError('invalid StructuralReadingResidualPosture discriminant: ' + String(d));
     }
 }
 export function encodeStructuralReadingResidualPosture(v) {
-    const w = new Writer();
+    const w = new RuntimeWriter();
     _encStructuralReadingResidualPosture(w, v);
     return w.finish();
 }
 export function decodeStructuralReadingResidualPosture(b) {
-    return _decStructuralReadingResidualPosture(new Reader(b));
+    return decodeWithBoundary(b, (r) => _decStructuralReadingResidualPosture(r));
+}
+export function _encStructuralRepository(w, v) {
+    w.writeString(v.repositoryId);
+    w.writeString(v.rootKey);
+    w.writeOption(v.defaultBranch, (w, x) => w.writeString(x));
+    w.writeString(v.summary);
+}
+export function _decStructuralRepository(r) {
+    return {
+        repositoryId: r.readString(),
+        rootKey: r.readString(),
+        defaultBranch: r.readOption((r) => r.readString()),
+        summary: r.readString(),
+    };
+}
+export function _encStructuralSourceSpan(w, v) {
+    w.writeString(v.spanId);
+    w.writeString(v.fileVersionId);
+    _encSourceSpanEncoding(w, v.encoding);
+    w.writeI32Le(v.startOffset);
+    w.writeI32Le(v.endOffset);
+    w.writeOption(v.startLine, (w, x) => w.writeI32Le(x));
+    w.writeOption(v.endLine, (w, x) => w.writeI32Le(x));
+    w.writeString(v.summary);
+}
+export function _decStructuralSourceSpan(r) {
+    return {
+        spanId: r.readString(),
+        fileVersionId: r.readString(),
+        encoding: _decSourceSpanEncoding(r),
+        startOffset: r.readI32Le(),
+        endOffset: r.readI32Le(),
+        startLine: r.readOption((r) => r.readI32Le()),
+        endLine: r.readOption((r) => r.readI32Le()),
+        summary: r.readString(),
+    };
 }
 export function _encStructuralSubstrateKind(w, v) {
     switch (v) {
@@ -305,7 +538,7 @@ export function _encStructuralSubstrateKind(w, v) {
         case 'GIT_WARP':
             w.writeU32Le(1);
             return;
-        default: throw new CodecError('invalid StructuralSubstrateKind variant: ' + String(v));
+        default: throw new RuntimeCodecError('invalid StructuralSubstrateKind variant: ' + String(v));
     }
 }
 export function _decStructuralSubstrateKind(r) {
@@ -313,16 +546,68 @@ export function _decStructuralSubstrateKind(r) {
     switch (d) {
         case 0: return 'ECHO';
         case 1: return 'GIT_WARP';
-        default: throw new CodecError('invalid StructuralSubstrateKind discriminant: ' + String(d));
+        default: throw new RuntimeCodecError('invalid StructuralSubstrateKind discriminant: ' + String(d));
     }
 }
 export function encodeStructuralSubstrateKind(v) {
-    const w = new Writer();
+    const w = new RuntimeWriter();
     _encStructuralSubstrateKind(w, v);
     return w.finish();
 }
 export function decodeStructuralSubstrateKind(b) {
-    return _decStructuralSubstrateKind(new Reader(b));
+    return decodeWithBoundary(b, (r) => _decStructuralSubstrateKind(r));
+}
+export function _encStructuralSymbol(w, v) {
+    w.writeString(v.symbolId);
+    w.writeString(v.repositoryId);
+    w.writeString(v.basisId);
+    w.writeString(v.fileVersionId);
+    w.writeOption(v.parserRunId, (w, x) => w.writeString(x));
+    w.writeString(v.name);
+    w.writeString(v.kind);
+    _encSymbolVisibility(w, v.visibility);
+    w.writeOption(v.declarationSpanId, (w, x) => w.writeString(x));
+    w.writeBool(v.exported);
+    w.writeString(v.summary);
+}
+export function _decStructuralSymbol(r) {
+    return {
+        symbolId: r.readString(),
+        repositoryId: r.readString(),
+        basisId: r.readString(),
+        fileVersionId: r.readString(),
+        parserRunId: r.readOption((r) => r.readString()),
+        name: r.readString(),
+        kind: r.readString(),
+        visibility: _decSymbolVisibility(r),
+        declarationSpanId: r.readOption((r) => r.readString()),
+        exported: r.readBool(),
+        summary: r.readString(),
+    };
+}
+export function _encStructuralSymbolRelation(w, v) {
+    w.writeString(v.relationId);
+    w.writeString(v.repositoryId);
+    w.writeString(v.basisId);
+    _encSymbolRelationKind(w, v.relationKind);
+    w.writeOption(v.fromSymbolId, (w, x) => w.writeString(x));
+    w.writeOption(v.toSymbolId, (w, x) => w.writeString(x));
+    w.writeOption(v.fileVersionId, (w, x) => w.writeString(x));
+    w.writeOption(v.spanId, (w, x) => w.writeString(x));
+    w.writeString(v.summary);
+}
+export function _decStructuralSymbolRelation(r) {
+    return {
+        relationId: r.readString(),
+        repositoryId: r.readString(),
+        basisId: r.readString(),
+        relationKind: _decSymbolRelationKind(r),
+        fromSymbolId: r.readOption((r) => r.readString()),
+        toSymbolId: r.readOption((r) => r.readString()),
+        fileVersionId: r.readOption((r) => r.readString()),
+        spanId: r.readOption((r) => r.readString()),
+        summary: r.readString(),
+    };
 }
 export function _encSymbolRelationKind(w, v) {
     switch (v) {
@@ -344,7 +629,7 @@ export function _encSymbolRelationKind(w, v) {
         case 'REMOVES':
             w.writeU32Le(5);
             return;
-        default: throw new CodecError('invalid SymbolRelationKind variant: ' + String(v));
+        default: throw new RuntimeCodecError('invalid SymbolRelationKind variant: ' + String(v));
     }
 }
 export function _decSymbolRelationKind(r) {
@@ -356,16 +641,16 @@ export function _decSymbolRelationKind(r) {
         case 3: return 'CALLS';
         case 4: return 'DEFINES';
         case 5: return 'REMOVES';
-        default: throw new CodecError('invalid SymbolRelationKind discriminant: ' + String(d));
+        default: throw new RuntimeCodecError('invalid SymbolRelationKind discriminant: ' + String(d));
     }
 }
 export function encodeSymbolRelationKind(v) {
-    const w = new Writer();
+    const w = new RuntimeWriter();
     _encSymbolRelationKind(w, v);
     return w.finish();
 }
 export function decodeSymbolRelationKind(b) {
-    return _decSymbolRelationKind(new Reader(b));
+    return decodeWithBoundary(b, (r) => _decSymbolRelationKind(r));
 }
 export function _encSymbolVisibility(w, v) {
     switch (v) {
@@ -378,7 +663,7 @@ export function _encSymbolVisibility(w, v) {
         case 'UNKNOWN':
             w.writeU32Le(2);
             return;
-        default: throw new CodecError('invalid SymbolVisibility variant: ' + String(v));
+        default: throw new RuntimeCodecError('invalid SymbolVisibility variant: ' + String(v));
     }
 }
 export function _decSymbolVisibility(r) {
@@ -387,159 +672,177 @@ export function _decSymbolVisibility(r) {
         case 0: return 'LOCAL';
         case 1: return 'EXPORTED';
         case 2: return 'UNKNOWN';
-        default: throw new CodecError('invalid SymbolVisibility discriminant: ' + String(d));
+        default: throw new RuntimeCodecError('invalid SymbolVisibility discriminant: ' + String(d));
     }
 }
 export function encodeSymbolVisibility(v) {
-    const w = new Writer();
+    const w = new RuntimeWriter();
     _encSymbolVisibility(w, v);
     return w.finish();
 }
 export function decodeSymbolVisibility(b) {
-    return _decSymbolVisibility(new Reader(b));
+    return decodeWithBoundary(b, (r) => _decSymbolVisibility(r));
 }
-// ─── query structuralRepositories ───
-/** EINT op id for query `structuralRepositories`. Stable across Rust and TypeScript emitters. */
-export const OP_STRUCTURAL_REPOSITORIES = 2032910390;
-export function encodeStructuralRepositoriesVars(v) {
-    const w = new Writer();
+export function _encStructuralRepositoriesVars(w, v) {
     w.writeOption(v.repositoryId, (w, x) => w.writeString(x));
-    return w.finish();
 }
-export function decodeStructuralRepositoriesVars(b) {
-    const r = new Reader(b);
+export function _decStructuralRepositoriesVars(r) {
     return {
         repositoryId: r.readOption((r) => r.readString()),
     };
 }
-// ─── query structuralBases ───
-/** EINT op id for query `structuralBases`. Stable across Rust and TypeScript emitters. */
-export const OP_STRUCTURAL_BASES = 1248717276;
-export function encodeStructuralBasesVars(v) {
-    const w = new Writer();
+export function encodeStructuralRepositoriesVars(v) {
+    const w = new RuntimeWriter();
+    _encStructuralRepositoriesVars(w, v);
+    return w.finish();
+}
+export function decodeStructuralRepositoriesVars(b) {
+    return decodeWithBoundary(b, (r) => _decStructuralRepositoriesVars(r));
+}
+export function _encStructuralBasesVars(w, v) {
     w.writeString(v.repositoryId);
     w.writeOption(v.basisKind, (w, x) => _encStructuralBasisKind(w, x));
-    return w.finish();
 }
-export function decodeStructuralBasesVars(b) {
-    const r = new Reader(b);
+export function _decStructuralBasesVars(r) {
     return {
         repositoryId: r.readString(),
         basisKind: r.readOption((r) => _decStructuralBasisKind(r)),
     };
 }
-// ─── query structuralFileVersions ───
-/** EINT op id for query `structuralFileVersions`. Stable across Rust and TypeScript emitters. */
-export const OP_STRUCTURAL_FILE_VERSIONS = 1424315131;
-export function encodeStructuralFileVersionsVars(v) {
-    const w = new Writer();
+export function encodeStructuralBasesVars(v) {
+    const w = new RuntimeWriter();
+    _encStructuralBasesVars(w, v);
+    return w.finish();
+}
+export function decodeStructuralBasesVars(b) {
+    return decodeWithBoundary(b, (r) => _decStructuralBasesVars(r));
+}
+export function _encStructuralFileVersionsVars(w, v) {
     w.writeString(v.basisId);
     w.writeOption(v.path, (w, x) => w.writeString(x));
-    return w.finish();
 }
-export function decodeStructuralFileVersionsVars(b) {
-    const r = new Reader(b);
+export function _decStructuralFileVersionsVars(r) {
     return {
         basisId: r.readString(),
         path: r.readOption((r) => r.readString()),
     };
 }
-// ─── query structuralSymbols ───
-/** EINT op id for query `structuralSymbols`. Stable across Rust and TypeScript emitters. */
-export const OP_STRUCTURAL_SYMBOLS = 1921506065;
-export function encodeStructuralSymbolsVars(v) {
-    const w = new Writer();
+export function encodeStructuralFileVersionsVars(v) {
+    const w = new RuntimeWriter();
+    _encStructuralFileVersionsVars(w, v);
+    return w.finish();
+}
+export function decodeStructuralFileVersionsVars(b) {
+    return decodeWithBoundary(b, (r) => _decStructuralFileVersionsVars(r));
+}
+export function _encStructuralSymbolsVars(w, v) {
     w.writeString(v.basisId);
     w.writeOption(v.fileVersionId, (w, x) => w.writeString(x));
     w.writeOption(v.name, (w, x) => w.writeString(x));
-    return w.finish();
 }
-export function decodeStructuralSymbolsVars(b) {
-    const r = new Reader(b);
+export function _decStructuralSymbolsVars(r) {
     return {
         basisId: r.readString(),
         fileVersionId: r.readOption((r) => r.readString()),
         name: r.readOption((r) => r.readString()),
     };
 }
-// ─── query structuralSymbolRelations ───
-/** EINT op id for query `structuralSymbolRelations`. Stable across Rust and TypeScript emitters. */
-export const OP_STRUCTURAL_SYMBOL_RELATIONS = 3823410673;
-export function encodeStructuralSymbolRelationsVars(v) {
-    const w = new Writer();
+export function encodeStructuralSymbolsVars(v) {
+    const w = new RuntimeWriter();
+    _encStructuralSymbolsVars(w, v);
+    return w.finish();
+}
+export function decodeStructuralSymbolsVars(b) {
+    return decodeWithBoundary(b, (r) => _decStructuralSymbolsVars(r));
+}
+export function _encStructuralSymbolRelationsVars(w, v) {
     w.writeString(v.basisId);
     w.writeOption(v.symbolId, (w, x) => w.writeString(x));
     w.writeOption(v.relationKind, (w, x) => _encSymbolRelationKind(w, x));
-    return w.finish();
 }
-export function decodeStructuralSymbolRelationsVars(b) {
-    const r = new Reader(b);
+export function _decStructuralSymbolRelationsVars(r) {
     return {
         basisId: r.readString(),
         symbolId: r.readOption((r) => r.readString()),
         relationKind: r.readOption((r) => _decSymbolRelationKind(r)),
     };
 }
-// ─── query structuralReadings ───
-/** EINT op id for query `structuralReadings`. Stable across Rust and TypeScript emitters. */
-export const OP_STRUCTURAL_READINGS = 2423586293;
-export function encodeStructuralReadingsVars(v) {
-    const w = new Writer();
+export function encodeStructuralSymbolRelationsVars(v) {
+    const w = new RuntimeWriter();
+    _encStructuralSymbolRelationsVars(w, v);
+    return w.finish();
+}
+export function decodeStructuralSymbolRelationsVars(b) {
+    return decodeWithBoundary(b, (r) => _decStructuralSymbolRelationsVars(r));
+}
+export function _encStructuralReadingsVars(w, v) {
     w.writeString(v.basisId);
     w.writeOption(v.readingKind, (w, x) => _encStructuralReadingKind(w, x));
-    return w.finish();
 }
-export function decodeStructuralReadingsVars(b) {
-    const r = new Reader(b);
+export function _decStructuralReadingsVars(r) {
     return {
         basisId: r.readString(),
         readingKind: r.readOption((r) => _decStructuralReadingKind(r)),
     };
 }
-// ─── query structuralReadingEvidence ───
-/** EINT op id for query `structuralReadingEvidence`. Stable across Rust and TypeScript emitters. */
-export const OP_STRUCTURAL_READING_EVIDENCE = 1860328781;
-export function encodeStructuralReadingEvidenceVars(v) {
-    const w = new Writer();
+export function encodeStructuralReadingsVars(v) {
+    const w = new RuntimeWriter();
+    _encStructuralReadingsVars(w, v);
+    return w.finish();
+}
+export function decodeStructuralReadingsVars(b) {
+    return decodeWithBoundary(b, (r) => _decStructuralReadingsVars(r));
+}
+export function _encStructuralReadingEvidenceVars(w, v) {
     w.writeOption(v.evidenceId, (w, x) => w.writeString(x));
     w.writeOption(v.basisId, (w, x) => w.writeString(x));
-    return w.finish();
 }
-export function decodeStructuralReadingEvidenceVars(b) {
-    const r = new Reader(b);
+export function _decStructuralReadingEvidenceVars(r) {
     return {
         evidenceId: r.readOption((r) => r.readString()),
         basisId: r.readOption((r) => r.readString()),
     };
 }
-// ─── query gitWarpImportBatches ───
-/** EINT op id for query `gitWarpImportBatches`. Stable across Rust and TypeScript emitters. */
-export const OP_GIT_WARP_IMPORT_BATCHES = 533666208;
-export function encodeGitWarpImportBatchesVars(v) {
-    const w = new Writer();
+export function encodeStructuralReadingEvidenceVars(v) {
+    const w = new RuntimeWriter();
+    _encStructuralReadingEvidenceVars(w, v);
+    return w.finish();
+}
+export function decodeStructuralReadingEvidenceVars(b) {
+    return decodeWithBoundary(b, (r) => _decStructuralReadingEvidenceVars(r));
+}
+export function _encGitWarpImportBatchesVars(w, v) {
     w.writeString(v.repositoryId);
     w.writeOption(v.parity, (w, x) => _encMigrationParityStatus(w, x));
-    return w.finish();
 }
-export function decodeGitWarpImportBatchesVars(b) {
-    const r = new Reader(b);
+export function _decGitWarpImportBatchesVars(r) {
     return {
         repositoryId: r.readString(),
         parity: r.readOption((r) => _decMigrationParityStatus(r)),
     };
 }
-// ─── mutation recordGitWarpImportBatch ───
-/** EINT op id for mutation `recordGitWarpImportBatch`. Stable across Rust and TypeScript emitters. */
-export const OP_RECORD_GIT_WARP_IMPORT_BATCH = 2574440766;
-export function encodeRecordGitWarpImportBatchVars(v) {
-    const w = new Writer();
-    _encRecordGitWarpImportBatchInput(w, v.input);
+export function encodeGitWarpImportBatchesVars(v) {
+    const w = new RuntimeWriter();
+    _encGitWarpImportBatchesVars(w, v);
     return w.finish();
 }
-export function decodeRecordGitWarpImportBatchVars(b) {
-    const r = new Reader(b);
+export function decodeGitWarpImportBatchesVars(b) {
+    return decodeWithBoundary(b, (r) => _decGitWarpImportBatchesVars(r));
+}
+export function _encRecordGitWarpImportBatchVars(w, v) {
+    _encRecordGitWarpImportBatchInput(w, v.input);
+}
+export function _decRecordGitWarpImportBatchVars(r) {
     return {
         input: _decRecordGitWarpImportBatchInput(r),
     };
 }
+export function encodeRecordGitWarpImportBatchVars(v) {
+    const w = new RuntimeWriter();
+    _encRecordGitWarpImportBatchVars(w, v);
+    return w.finish();
+}
+export function decodeRecordGitWarpImportBatchVars(b) {
+    return decodeWithBoundary(b, (r) => _decRecordGitWarpImportBatchVars(r));
+}
 //# sourceMappingURL=graft-structural-history.codec.generated.js.map