@laserdata/laser-sdk 0.1.1 → 0.2.1

package/dist/wire/http.js

@@ -1,16 +1,22 @@
 import { CodecError } from "../client/errors.js";
 import { decodeProjectionInfo, decodeSchemaInfo, encodeProjectionInfo, encodeSchemaInfo } from "./browse.js";
-import { expectMap, field } from "./cbor.js";
+import { expectMap, expectString, field } from "./cbor.js";
 import { decodeSchemaDef, encodeSchemaDef } from "./control.js";
 import { decodeForkInfo, encodeForkInfo } from "./fork.js";
 import { decodeBackendDescriptor, decodeOpVersions, encodeBackendDescriptor, encodeOpVersions } from "./hello.js";
 import { decodeMemoryRowScope, encodeMemoryRowScope } from "./kv.js";
-import { consistencyToWord, decodeQueryResult, encodeQueryResult, parseConsistency } from "./query.js";
+import { consistencyToWord, decodeQueryResult, encodeQueryResult, parseConsistency, decodeQueryExecutionStatus, encodeQueryExecutionStatus } from "./query.js";
 import { decodeSourceRef, encodeSourceRef } from "./graph.js";
 import {} from "./result.js";
 import { decodeWireTopology, encodeWireTopology } from "./topology.js";
+import { bigIntToBytes16, bytes16ToBigInt, CheckpointRequestId, crockfordDecode, crockfordEncode, DestinationId, DestinationOperationId } from "./ids.js";
+import { decodeDestinationBlock, decodeDestinationCheckpointStatus, decodePreparedAttemptSummary, decodeRetentionGap, encodeDestinationBlock, encodeDestinationCheckpointStatus, encodePreparedAttemptSummary, encodeRetentionGap } from "./checkpoint.js";
+import { decodeMaterializationDestination, decodeQueryRoute, encodeMaterializationDestination, encodeQueryRoute } from "./destination.js";
+import { decodeLogicalSchema, decodeTypedValue, encodeLogicalSchema, encodeTypedValue } from "./schema.js";
 export const CAPABILITIES_PATH = "/agdx/capabilities";
 export const QUERY_PATH = "/agdx/query";
+export const DESTINATIONS_PATH = "/agdx/destinations";
+export const QUERY_ROUTES_PATH = "/agdx/query-routes";
 export const PROJECTIONS_PATH = "/agdx/projections";
 export const BINDINGS_PATH = "/agdx/bindings";
 export const SCHEMAS_PATH = "/agdx/schemas";
@@ -37,6 +43,24 @@ export const forkPromotePath = (id) => `${forkPath(id)}/promote`;
 export const forkRowsPath = (id) => `${forkPath(id)}/rows`;
 export const runPath = (id) => `${RUNS_PATH}/${id}`;
 export const runCancelPath = (id) => `${runPath(id)}/cancel`;
+export const destinationPath = (id) => `${DESTINATIONS_PATH}/${id.toString()}`;
+export const destinationEnablePath = (id) => `${destinationPath(id)}/enable`;
+export const destinationDisablePath = (id) => `${destinationPath(id)}/disable`;
+export const destinationStatusPath = (id) => `${destinationPath(id)}/status`;
+export const destinationCheckpointPath = (id) => `${destinationPath(id)}/checkpoint`;
+export const destinationRetentionGapPath = (id) => `${destinationPath(id)}/retention-gap`;
+export const destinationPreparedAttemptPath = (id) => `${destinationPath(id)}/prepared-attempt`;
+export const destinationTablePath = (id) => `${destinationPath(id)}/table`;
+export const destinationTableSchemaPath = (id) => `${destinationTablePath(id)}/schema`;
+export const destinationSnapshotsPath = (id) => `${destinationTablePath(id)}/snapshots`;
+export const destinationCurrentSnapshotPath = (id) => `${destinationTablePath(id)}/current-snapshot`;
+export const destinationSnapshotPath = (id, snapshotId) => `${destinationSnapshotsPath(id)}/${snapshotId.toString()}`;
+export const destinationFilesPath = (id) => `${destinationTablePath(id)}/files`;
+export const destinationMetricsPath = (id) => `${destinationTablePath(id)}/metrics`;
+export const queryExecutionPath = (id) => `${QUERY_PATH}/${id.toString()}`;
+export const queryPagePath = (id) => `${queryExecutionPath(id)}/pages`;
+export const queryCancelPath = (id) => `${queryExecutionPath(id)}/cancel`;
+export const destinationOperationPath = (id) => `${DESTINATIONS_PATH}/operations/${id.toString()}`;
 const RESULT_NAMES = new Map([
     ["ok", { kind: "known", name: "Ok" }],
     ["unsupported", { kind: "known", name: "Unsupported" }],
@@ -50,7 +74,13 @@ const RESULT_NAMES = new Map([
     ["backend", { kind: "known", name: "Backend" }],
     ["forbidden", { kind: "known", name: "Forbidden" }],
     ["step_up_required", { kind: "known", name: "StepUpRequired" }],
-    ["unavailable", { kind: "known", name: "Unavailable" }]
+    ["unavailable", { kind: "known", name: "Unavailable" }],
+    ["resource_limit", { kind: "known", name: "ResourceLimit" }],
+    ["cancelled", { kind: "known", name: "Cancelled" }],
+    ["deadline_exceeded", { kind: "known", name: "DeadlineExceeded" }],
+    ["expired_snapshot", { kind: "known", name: "ExpiredSnapshot" }],
+    ["stale_generation", { kind: "known", name: "StaleGeneration" }],
+    ["target_unavailable", { kind: "known", name: "TargetUnavailable" }]
 ]);
 const RESULT_WORDS = {
     Ok: "ok",
@@ -65,7 +95,13 @@ const RESULT_WORDS = {
     Backend: "backend",
     Forbidden: "forbidden",
     StepUpRequired: "step_up_required",
-    Unavailable: "unavailable"
+    Unavailable: "unavailable",
+    ResourceLimit: "resource_limit",
+    Cancelled: "cancelled",
+    DeadlineExceeded: "deadline_exceeded",
+    ExpiredSnapshot: "expired_snapshot",
+    StaleGeneration: "stale_generation",
+    TargetUnavailable: "target_unavailable"
 };
 function parseJson(text, context) {
     try {
@@ -77,7 +113,34 @@ function parseJson(text, context) {
         throw new CodecError(`failed to decode ${context}`, context, "decode", { cause });
     }
 }
+const READABLE_ID_FIELDS = new Set([
+    "backend_resource_id",
+    "cluster",
+    "destination_id",
+    "execution_id",
+    "operation_id",
+    "owner",
+    "request_id",
+    "resource_id"
+]);
+function isReadableIdContext(context) {
+    const fieldName = /\.([^.[\]]+)$/.exec(context)?.[1];
+    if (fieldName !== undefined && READABLE_ID_FIELDS.has(fieldName))
+        return true;
+    return context.endsWith(".destination.id") || /\.routes\[\d+\]\.id$/.test(context);
+}
+function readableIdFromJson(value, context) {
+    try {
+        return bigIntToBytes16(crockfordDecode(value));
+    }
+    catch (cause) {
+        throw new CodecError(`${context} must be a Crockford base32 id`, context, "string", { cause });
+    }
+}
 function fromJsonValue(value, context) {
+    if (typeof value === "string" && isReadableIdContext(context)) {
+        return readableIdFromJson(value, context);
+    }
     if (value === null || typeof value === "string" || typeof value === "boolean")
         return value;
     if (typeof value === "number") {
@@ -91,7 +154,11 @@ function fromJsonValue(value, context) {
         return value;
     }
     if (Array.isArray(value)) {
-        if (value.every((item) => Number.isInteger(item) && Number(item) >= 0 && Number(item) <= 255)) {
+        if (isReadableIdContext(context)) {
+            throw new CodecError(`${context} must be a Crockford base32 id`, context, "string");
+        }
+        if (value.length > 0 &&
+            value.every((item) => Number.isInteger(item) && Number(item) >= 0 && Number(item) <= 255)) {
             return Uint8Array.from(value);
         }
         return value.map((item, index) => fromJsonValue(item, `${context}[${String(index)}]`));
@@ -109,8 +176,15 @@ function toJsonValue(value, context) {
         }
         return number;
     }
-    if (value instanceof Uint8Array)
+    if (value instanceof Uint8Array) {
+        if (isReadableIdContext(context)) {
+            if (value.length !== 16) {
+                throw new CodecError(`${context} must contain 16 bytes`, context, "bytes");
+            }
+            return crockfordEncode(bytes16ToBigInt(value));
+        }
         return [...value];
+    }
     if (value instanceof Map) {
         return Object.fromEntries([...value].map(([key, item]) => {
             if (typeof key !== "string") {
@@ -149,13 +223,383 @@ export function decodeQueryResultJson(text) {
     return decodeQueryResult(expectMap(parseJson(text, "QueryResult"), "QueryResult"), "QueryResult");
 }
 export const encodeQueryResultJson = (result) => encodeJson(encodeQueryResult(result), "QueryResult");
+function fixedBytes(value, length, context) {
+    if (value.length !== length) {
+        throw new CodecError(`${context} must contain ${String(length)} bytes`, context, "bytes");
+    }
+    return value;
+}
+function enumWord(map, key, context, values) {
+    const value = field.requiredString(map, key, context);
+    if (!values.includes(value)) {
+        throw new CodecError(`unknown ${key} \`${value}\``, context, key);
+    }
+    return value;
+}
+function parseResultCode(value, context) {
+    const code = RESULT_NAMES.get(value);
+    if (code === undefined)
+        throw new CodecError(`unknown result code \`${value}\``, context, "code");
+    return code;
+}
+function encodeResultCode(value, context) {
+    if (value.kind === "unrecognized") {
+        throw new CodecError("unrecognized numeric result codes have no JSON spelling", context, "code");
+    }
+    const word = RESULT_WORDS[value.name];
+    if (word === undefined)
+        throw new CodecError("result code has no JSON spelling", context, "code");
+    return word;
+}
+function decodeStringMap(map, context) {
+    return new Map([...map].map(([key, value]) => {
+        const name = expectString(key, `${context} key`);
+        return [name, expectString(value, `${context}.${name}`)];
+    }));
+}
+function encodeStringMap(value) {
+    return new Map([...value].sort(([left], [right]) => left.localeCompare(right)));
+}
+function decodeTypedValueMap(map, context) {
+    return new Map([...map].map(([key, value]) => {
+        const name = expectString(key, `${context} key`);
+        return [name, decodeTypedValue(value, `${context}.${name}`)];
+    }));
+}
+function encodeTypedValueMap(value) {
+    return new Map([...value]
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([key, item]) => [key, encodeTypedValue(item)]));
+}
+function parseFieldId(key, context) {
+    const value = Number(key);
+    if (!Number.isInteger(value) || value < 0 || value > 0xffff_ffff || String(value) !== key) {
+        throw new CodecError(`invalid field id \`${key}\``, context, "key");
+    }
+    return value;
+}
+function decodeFieldValueMap(map, context) {
+    return new Map([...map].map(([key, value]) => {
+        const name = expectString(key, `${context} key`);
+        return [parseFieldId(name, context), decodeTypedValue(value, `${context}.${name}`)];
+    }));
+}
+function encodeFieldValueMap(value) {
+    return new Map([...value]
+        .sort(([left], [right]) => left - right)
+        .map(([key, item]) => [String(key), encodeTypedValue(item)]));
+}
+function decodeFieldCountMap(map, context) {
+    return new Map([...map].map(([key]) => {
+        const name = expectString(key, `${context} key`);
+        return [parseFieldId(name, context), field.requiredU64(map, name, context)];
+    }));
+}
+function encodeFieldCountMap(value) {
+    return new Map([...value].sort(([left], [right]) => left - right).map(([key, item]) => [String(key), item]));
+}
+function decodeDestinationView(map, context) {
+    return {
+        destination: decodeMaterializationDestination(field.requiredMap(map, "destination", context), `${context}.destination`),
+        status: decodeDestinationCheckpointStatus(field.requiredMap(map, "status", context), `${context}.status`)
+    };
+}
+function encodeDestinationView(value) {
+    return new Map([
+        ["destination", encodeMaterializationDestination(value.destination)],
+        ["status", encodeDestinationCheckpointStatus(value.status)]
+    ]);
+}
+export function decodeDestinationPageJson(text) {
+    const context = "DestinationPageView";
+    const map = expectMap(parseJson(text, context), context);
+    const nextCursor = field.optionalString(map, "next_cursor", context);
+    return {
+        destinations: field.requiredArray(map, "destinations", context, (item, index) => decodeDestinationView(expectMap(item, `${context}.destinations[${String(index)}]`), `${context}.destinations[${String(index)}]`)),
+        ...(nextCursor === undefined ? {} : { nextCursor }),
+        globalStateRevision: field.requiredU64(map, "global_state_revision", context),
+        consistency: enumWord(map, "consistency", context, ["linearizable", "potentially_stale"])
+    };
+}
+export function encodeDestinationPageJson(value) {
+    const map = new Map([
+        ["destinations", value.destinations.map(encodeDestinationView)]
+    ]);
+    if (value.nextCursor !== undefined)
+        map.set("next_cursor", value.nextCursor);
+    map.set("global_state_revision", value.globalStateRevision);
+    map.set("consistency", value.consistency);
+    return encodeJson(map, "DestinationPageView");
+}
+export function decodeQueryRoutePageJson(text) {
+    const context = "QueryRoutePageView";
+    const map = expectMap(parseJson(text, context), context);
+    const nextCursor = field.optionalString(map, "next_cursor", context);
+    return {
+        routes: field.requiredArray(map, "routes", context, (item, index) => decodeQueryRoute(expectMap(item, `${context}.routes[${String(index)}]`), `${context}.routes[${String(index)}]`)),
+        ...(nextCursor === undefined ? {} : { nextCursor }),
+        definitionRevision: field.requiredU64(map, "definition_revision", context)
+    };
+}
+export function encodeQueryRoutePageJson(value) {
+    const map = new Map([["routes", value.routes.map(encodeQueryRoute)]]);
+    if (value.nextCursor !== undefined)
+        map.set("next_cursor", value.nextCursor);
+    map.set("definition_revision", value.definitionRevision);
+    return encodeJson(map, "QueryRoutePageView");
+}
+export function decodeTableViewJson(text) {
+    const context = "TableView";
+    const map = expectMap(parseJson(text, context), context);
+    return {
+        tableUuid: fixedBytes(field.requiredBytes(map, "table_uuid", context), 16, `${context}.table_uuid`),
+        destinationId: DestinationId.fromBytes(field.requiredBytes(map, "destination_id", context)),
+        destinationGeneration: field.requiredU64(map, "destination_generation", context),
+        namespace: field.requiredArray(map, "namespace", context, (item, index) => expectString(item, `${context}.namespace[${String(index)}]`)),
+        table: field.requiredString(map, "table", context),
+        currentSnapshotId: field.requiredI64(map, "current_snapshot_id", context),
+        currentSchemaId: field.requiredI32(map, "current_schema_id", context),
+        currentPartitionSpecId: field.requiredI32(map, "current_partition_spec_id", context),
+        metadataIdentity: field.requiredString(map, "metadata_identity", context),
+        properties: decodeStringMap(field.requiredMap(map, "properties", context), `${context}.properties`)
+    };
+}
+export function encodeTableViewJson(value) {
+    return encodeJson(new Map([
+        ["table_uuid", value.tableUuid],
+        ["destination_id", value.destinationId.toBytes()],
+        ["destination_generation", value.destinationGeneration],
+        ["namespace", [...value.namespace]],
+        ["table", value.table],
+        ["current_snapshot_id", value.currentSnapshotId],
+        ["current_schema_id", value.currentSchemaId],
+        ["current_partition_spec_id", value.currentPartitionSpecId],
+        ["metadata_identity", value.metadataIdentity],
+        ["properties", encodeStringMap(value.properties)]
+    ]), "TableView");
+}
+export function decodeTableSchemaJson(text) {
+    const context = "TableSchemaView";
+    const map = expectMap(parseJson(text, context), context);
+    return {
+        tableUuid: fixedBytes(field.requiredBytes(map, "table_uuid", context), 16, `${context}.table_uuid`),
+        icebergSchemaId: field.requiredI32(map, "iceberg_schema_id", context),
+        logicalSchema: decodeLogicalSchema(field.requiredMap(map, "logical_schema", context), `${context}.logical_schema`)
+    };
+}
+export function encodeTableSchemaJson(value) {
+    return encodeJson(new Map([
+        ["table_uuid", value.tableUuid],
+        ["iceberg_schema_id", value.icebergSchemaId],
+        ["logical_schema", encodeLogicalSchema(value.logicalSchema)]
+    ]), "TableSchemaView");
+}
+function decodeTableSnapshot(map, context) {
+    const parentSnapshotId = field.optionalI64(map, "parent_snapshot_id", context);
+    return {
+        snapshotId: field.requiredI64(map, "snapshot_id", context),
+        ...(parentSnapshotId === undefined ? {} : { parentSnapshotId }),
+        sequenceNumber: field.requiredI64(map, "sequence_number", context),
+        committedAtMicros: field.requiredU64(map, "committed_at_micros", context),
+        schemaId: field.requiredI32(map, "schema_id", context),
+        partitionSpecId: field.requiredI32(map, "partition_spec_id", context),
+        materializationBoundaryDigest: fixedBytes(field.requiredBytes(map, "materialization_boundary_digest", context), 32, `${context}.materialization_boundary_digest`),
+        checkpointRevision: field.requiredU64(map, "checkpoint_revision", context),
+        summary: decodeStringMap(field.requiredMap(map, "summary", context), `${context}.summary`)
+    };
+}
+function encodeTableSnapshot(value) {
+    const map = new Map([["snapshot_id", value.snapshotId]]);
+    if (value.parentSnapshotId !== undefined)
+        map.set("parent_snapshot_id", value.parentSnapshotId);
+    map.set("sequence_number", value.sequenceNumber);
+    map.set("committed_at_micros", value.committedAtMicros);
+    map.set("schema_id", value.schemaId);
+    map.set("partition_spec_id", value.partitionSpecId);
+    map.set("materialization_boundary_digest", value.materializationBoundaryDigest);
+    map.set("checkpoint_revision", value.checkpointRevision);
+    map.set("summary", encodeStringMap(value.summary));
+    return map;
+}
+export function decodeSnapshotPageJson(text) {
+    const context = "SnapshotPageView";
+    const map = expectMap(parseJson(text, context), context);
+    const nextBeforeSnapshotId = field.optionalI64(map, "next_before_snapshot_id", context);
+    return {
+        snapshots: field.requiredArray(map, "snapshots", context, (item, index) => decodeTableSnapshot(expectMap(item, `${context}.snapshots[${String(index)}]`), `${context}.snapshots[${String(index)}]`)),
+        ...(nextBeforeSnapshotId === undefined ? {} : { nextBeforeSnapshotId })
+    };
+}
+export function encodeSnapshotPageJson(value) {
+    const map = new Map([["snapshots", value.snapshots.map(encodeTableSnapshot)]]);
+    if (value.nextBeforeSnapshotId !== undefined) {
+        map.set("next_before_snapshot_id", value.nextBeforeSnapshotId);
+    }
+    return encodeJson(map, "SnapshotPageView");
+}
+function decodeTableFile(map, context) {
+    return {
+        objectIdentity: field.requiredString(map, "object_identity", context),
+        fileSizeBytes: field.requiredU64(map, "file_size_bytes", context),
+        rowCount: field.requiredU64(map, "row_count", context),
+        partition: decodeTypedValueMap(field.requiredMap(map, "partition", context), `${context}.partition`),
+        lowerBounds: decodeFieldValueMap(field.requiredMap(map, "lower_bounds", context), `${context}.lower_bounds`),
+        upperBounds: decodeFieldValueMap(field.requiredMap(map, "upper_bounds", context), `${context}.upper_bounds`),
+        nullValueCounts: decodeFieldCountMap(field.requiredMap(map, "null_value_counts", context), `${context}.null_value_counts`)
+    };
+}
+function encodeTableFile(value) {
+    return new Map([
+        ["object_identity", value.objectIdentity],
+        ["file_size_bytes", value.fileSizeBytes],
+        ["row_count", value.rowCount],
+        ["partition", encodeTypedValueMap(value.partition)],
+        ["lower_bounds", encodeFieldValueMap(value.lowerBounds)],
+        ["upper_bounds", encodeFieldValueMap(value.upperBounds)],
+        ["null_value_counts", encodeFieldCountMap(value.nullValueCounts)]
+    ]);
+}
+export function decodeTableFilePageJson(text) {
+    const context = "TableFilePageView";
+    const map = expectMap(parseJson(text, context), context);
+    const nextCursor = field.optionalString(map, "next_cursor", context);
+    return {
+        files: field.requiredArray(map, "files", context, (item, index) => decodeTableFile(expectMap(item, `${context}.files[${String(index)}]`), `${context}.files[${String(index)}]`)),
+        ...(nextCursor === undefined ? {} : { nextCursor })
+    };
+}
+export function encodeTableFilePageJson(value) {
+    const map = new Map([["files", value.files.map(encodeTableFile)]]);
+    if (value.nextCursor !== undefined)
+        map.set("next_cursor", value.nextCursor);
+    return encodeJson(map, "TableFilePageView");
+}
+export function decodeTableMetricsJson(text) {
+    const context = "TableMetricsView";
+    const map = expectMap(parseJson(text, context), context);
+    return {
+        snapshotId: field.requiredI64(map, "snapshot_id", context),
+        dataFileCount: field.requiredU64(map, "data_file_count", context),
+        deleteFileCount: field.requiredU64(map, "delete_file_count", context),
+        totalRows: field.requiredU64(map, "total_rows", context),
+        totalBytes: field.requiredU64(map, "total_bytes", context),
+        partitionCount: field.requiredU64(map, "partition_count", context)
+    };
+}
+export function encodeTableMetricsJson(value) {
+    return encodeJson(new Map([
+        ["snapshot_id", value.snapshotId],
+        ["data_file_count", value.dataFileCount],
+        ["delete_file_count", value.deleteFileCount],
+        ["total_rows", value.totalRows],
+        ["total_bytes", value.totalBytes],
+        ["partition_count", value.partitionCount]
+    ]), "TableMetricsView");
+}
+export function decodeAcceptedOperationJson(text) {
+    const context = "AcceptedOperationView";
+    const map = expectMap(parseJson(text, context), context);
+    const completedAtMicros = field.optionalU64(map, "completed_at_micros", context);
+    const error = field.optionalMap(map, "error", context);
+    return {
+        operationId: DestinationOperationId.fromBytes(field.requiredBytes(map, "operation_id", context)),
+        requestId: CheckpointRequestId.fromBytes(field.requiredBytes(map, "request_id", context)),
+        state: enumWord(map, "state", context, [
+            "accepted",
+            "running",
+            "succeeded",
+            "failed",
+            "cancelled"
+        ]),
+        submittedAtMicros: field.requiredU64(map, "submitted_at_micros", context),
+        ...(completedAtMicros === undefined ? {} : { completedAtMicros }),
+        ...(error === undefined
+            ? {}
+            : {
+                error: {
+                    code: parseResultCode(field.requiredString(error, "code", context), `${context}.error`),
+                    message: field.requiredString(error, "message", context)
+                }
+            })
+    };
+}
+export function encodeAcceptedOperationJson(value) {
+    const context = "AcceptedOperationView";
+    const map = new Map([
+        ["operation_id", value.operationId.toBytes()],
+        ["request_id", value.requestId.toBytes()],
+        ["state", value.state],
+        ["submitted_at_micros", value.submittedAtMicros]
+    ]);
+    if (value.completedAtMicros !== undefined)
+        map.set("completed_at_micros", value.completedAtMicros);
+    if (value.error !== undefined) {
+        map.set("error", new Map([
+            ["code", encodeResultCode(value.error.code, `${context}.error`)],
+            ["message", value.error.message]
+        ]));
+    }
+    return encodeJson(map, "AcceptedOperationView");
+}
+export function decodeQueryExecutionJson(text) {
+    const context = "QueryExecutionView";
+    const map = expectMap(parseJson(text, context), context);
+    const result = field.optionalMap(map, "result", context);
+    return {
+        status: decodeQueryExecutionStatus(field.requiredMap(map, "status", context), `${context}.status`),
+        ...(result === undefined ? {} : { result: decodeQueryResult(result, `${context}.result`) })
+    };
+}
+export function encodeQueryExecutionJson(value) {
+    const map = new Map([["status", encodeQueryExecutionStatus(value.status)]]);
+    if (value.result !== undefined)
+        map.set("result", encodeQueryResult(value.result));
+    return encodeJson(map, "QueryExecutionView");
+}
+export function decodeDestinationIssueJson(text) {
+    const context = "DestinationIssueView";
+    const map = expectMap(parseJson(text, context), context);
+    const retentionGap = field.optionalMap(map, "retention_gap", context);
+    const preparedAttempt = field.optionalMap(map, "prepared_attempt", context);
+    const block = field.optionalMap(map, "block", context);
+    return {
+        ...(retentionGap === undefined
+            ? {}
+            : { retentionGap: decodeRetentionGap(retentionGap, `${context}.retention_gap`) }),
+        ...(preparedAttempt === undefined
+            ? {}
+            : {
+                preparedAttempt: decodePreparedAttemptSummary(preparedAttempt, `${context}.prepared_attempt`)
+            }),
+        ...(block === undefined ? {} : { block: decodeDestinationBlock(block, `${context}.block`) }),
+        checkpointRevision: field.requiredU64(map, "checkpoint_revision", context),
+        consistency: enumWord(map, "consistency", context, ["linearizable", "potentially_stale"])
+    };
+}
+export function encodeDestinationIssueJson(value) {
+    const map = new Map();
+    if (value.retentionGap !== undefined) {
+        map.set("retention_gap", encodeRetentionGap(value.retentionGap));
+    }
+    if (value.preparedAttempt !== undefined) {
+        map.set("prepared_attempt", encodePreparedAttemptSummary(value.preparedAttempt));
+    }
+    if (value.block !== undefined)
+        map.set("block", encodeDestinationBlock(value.block));
+    map.set("checkpoint_revision", value.checkpointRevision);
+    map.set("consistency", value.consistency);
+    return encodeJson(map, "DestinationIssueView");
+}
 function decodeQueryCaps(map, context) {
     return {
         available: field.requiredBoolean(map, "available", context),
         projections: field.requiredBoolean(map, "projections", context),
         schemas: field.requiredBoolean(map, "schemas", context),
         consistency: parseConsistency(field.optionalString(map, "consistency", context) ?? "eventual", context),
-        keyword: field.optionalBoolean(map, "keyword", context) ?? false
+        keyword: field.optionalBoolean(map, "keyword", context) ?? false,
+        cursorPaging: field.optionalBoolean(map, "cursor_paging", context) ?? false,
+        cancellation: field.optionalBoolean(map, "cancellation", context) ?? false,
+        executionStatus: field.optionalBoolean(map, "execution_status", context) ?? false
     };
 }
 function encodeQueryCaps(value) {
@@ -164,7 +608,40 @@ function encodeQueryCaps(value) {
         ["projections", value.projections],
         ["schemas", value.schemas],
         ["consistency", consistencyToWord(value.consistency)],
-        ["keyword", value.keyword]
+        ["keyword", value.keyword],
+        ["cursor_paging", value.cursorPaging],
+        ["cancellation", value.cancellation],
+        ["execution_status", value.executionStatus]
+    ]);
+}
+function decodeDestinationCaps(map, context) {
+    const consistency = field.optionalString(map, "strongest_consistency", context) ?? "potentially_stale";
+    if (consistency !== "potentially_stale" && consistency !== "linearizable") {
+        throw new CodecError(`unknown checkpoint consistency \`${consistency}\``, context, "strongest_consistency");
+    }
+    return {
+        available: field.requiredBoolean(map, "available", context),
+        lifecycle: field.optionalBoolean(map, "lifecycle", context) ?? false,
+        checkpointStatus: field.optionalBoolean(map, "checkpoint_status", context) ?? false,
+        queryRoutes: field.optionalBoolean(map, "query_routes", context) ?? false,
+        tableSchema: field.optionalBoolean(map, "table_schema", context) ?? false,
+        snapshots: field.optionalBoolean(map, "snapshots", context) ?? false,
+        files: field.optionalBoolean(map, "files", context) ?? false,
+        metrics: field.optionalBoolean(map, "metrics", context) ?? false,
+        strongestConsistency: consistency
+    };
+}
+function encodeDestinationCaps(value) {
+    return new Map([
+        ["available", value.available],
+        ["lifecycle", value.lifecycle],
+        ["checkpoint_status", value.checkpointStatus],
+        ["query_routes", value.queryRoutes],
+        ["table_schema", value.tableSchema],
+        ["snapshots", value.snapshots],
+        ["files", value.files],
+        ["metrics", value.metrics],
+        ["strongest_consistency", value.strongestConsistency]
     ]);
 }
 export function decodeCapabilitiesJson(text) {
@@ -174,11 +651,13 @@ export function decodeCapabilitiesJson(text) {
     return {
         managed: field.requiredBoolean(map, "managed", context),
         query: decodeQueryCaps(field.requiredMap(map, "query", context), `${context}.query`),
+        destinations: decodeDestinationCaps(field.requiredMap(map, "destinations", context), `${context}.destinations`),
         kv: {
             available: field.requiredBoolean(field.requiredMap(map, "kv", context), "available", `${context}.kv`),
             cas: field.optionalBoolean(field.requiredMap(map, "kv", context), "cas", `${context}.kv`) ??
                 false,
-            casFenced: field.optionalBoolean(field.requiredMap(map, "kv", context), "cas_fenced", `${context}.kv`) ?? false
+            casFenced: field.optionalBoolean(field.requiredMap(map, "kv", context), "cas_fenced", `${context}.kv`) ?? false,
+            fencedLeases: field.optionalBoolean(field.requiredMap(map, "kv", context), "fenced_leases", `${context}.kv`) ?? false
         },
         graph: field.optionalBoolean(map, "graph", context) ?? false,
         fork: field.requiredBoolean(map, "fork", context),
@@ -196,12 +675,14 @@ export function encodeCapabilitiesJson(value) {
     const map = new Map([
         ["managed", value.managed],
         ["query", encodeQueryCaps(value.query)],
+        ["destinations", encodeDestinationCaps(value.destinations)],
         [
             "kv",
             new Map([
                 ["available", value.kv.available],
                 ["cas", value.kv.cas],
-                ["cas_fenced", value.kv.casFenced]
+                ["cas_fenced", value.kv.casFenced],
+                ["fenced_leases", value.kv.fencedLeases]
             ])
         ],
         ["graph", value.graph],