@mdbase-dev/sdk 0.0.0-stage → 0.1.0-beta.153

package/dist/wire.js

@@ -0,0 +1,915 @@
+import { runtimeOp } from "./runtime-wire.js";
+import { attachmentContentV1 } from "./attachment-wire.js";
+import { any, b16, b32, bool, bytes, dataMap, either, enumOf, hash, int, list, mapped, SchemaError, struct, tstr, tuple, uint, union, uuid, value, } from "./codec.js";
+export const version = mapped("version", tuple("version", [uint, uint]), ([major, minor]) => ({ major, minor }), (v) => [v.major, v.minor]);
+export const RECOVERY = [
+    "fix_request",
+    "refresh",
+    "resolve_conflict",
+    "reauthorize",
+    "repair_collection",
+    "retry",
+    "free_space",
+    "upgrade",
+    "resolve_outcome",
+    "none",
+    "contact_support",
+];
+export const recovery = enumOf("recovery", RECOVERY);
+export const severity = enumOf("severity", ["warning", "error"]);
+export const issue = struct("issue", [
+    [0, "code", tstr],
+    [1, "severity", severity],
+    [2, "message", tstr],
+    [3, "details", value, "opt"],
+]);
+export const problem = struct("problem", [
+    [0, "code", tstr],
+    [1, "recovery", recovery],
+    [2, "message", tstr],
+    [3, "reason", tstr, "opt"],
+    [4, "details", value, "opt"],
+    [5, "retryAfterMs", uint, "opt"],
+    [6, "issues", list(issue), "opt"],
+    [7, "traceId", tstr, "opt"],
+]);
+export const clientFrame = union("client-frame", [
+    [
+        0,
+        "request",
+        [
+            [1, "id", uint],
+            [2, "method", tstr],
+            [3, "params", any],
+        ],
+    ],
+    [
+        1,
+        "response",
+        [
+            [1, "id", uint],
+            [2, "result", any, "opt"],
+            [3, "problem", problem, "opt"],
+        ],
+    ],
+    [
+        2,
+        "push",
+        [
+            [1, "type", tstr],
+            [2, "payload", any],
+        ],
+    ],
+]);
+export const helloParams = struct("hello-params", [
+    [0, "versions", list(version, { nonEmpty: true }), "req1"],
+    [1, "clientName", tstr],
+    [2, "clientVersion", tstr],
+    [3, "features", list(tstr), "opt"],
+    [4, "timezone", tstr, "opt"],
+]);
+export const ROLES = ["viewer", "editor", "owner"];
+export const role = enumOf("role", ROLES);
+export const grantInfo = struct("grant-info", [
+    [0, "grant", uuid, "opt"],
+    [1, "capabilities", list(tstr, { nonEmpty: true }), "req1"],
+    [2, "role", role],
+    [3, "account", uuid, "opt"],
+    [4, "fileFolders", list(tstr), "opt"],
+]);
+export const INCIDENT_KINDS = [
+    "upgrade_required",
+    "waiting_for_key",
+    "integrity",
+    "access_revoked",
+    "quota_exceeded",
+    "read_only",
+    "verification_mismatch",
+    "voided_items",
+    "key_inconsistent",
+    "foreign_sync_tool",
+    "gone",
+    "lost_entries",
+    "log_regressed",
+];
+export const incident = struct("incident", [
+    [0, "kind", enumOf("incident-kind", INCIDENT_KINDS)],
+    [1, "details", value, "opt"],
+]);
+export const progress = struct("progress", [
+    [0, "done", uint],
+    [1, "total", uint],
+]);
+export const resyncing = struct("resyncing", [
+    [0, "phase", enumOf("resync-phase", ["probing", "repairing", "rolling_back", "awaiting_control"])],
+    [1, "positions", uint],
+]);
+export const confirmedHead = struct("confirmed-head", [
+    [0, "seq", uint],
+    [1, "chain", hash],
+    [2, "policyGeneration", hash],
+    [3, "catalogGeneration", hash],
+]);
+export const appliedPrefixParams = struct("applied-prefix-params", [[0, "seq", uint]]);
+export const appliedPrefix = struct("applied-prefix", [
+    [0, "appliedThrough", uint],
+    [1, "seq", uint],
+    [2, "chain", hash, "opt"],
+]);
+export const syncStatus = struct("sync-status", [
+    [0, "mode", enumOf("sync-mode", ["local_only", "synced"])],
+    [1, "confirmedThrough", uint],
+    [2, "headKnown", uint],
+    [3, "pending", uint],
+    [4, "oldestPending", int, "opt"],
+    [5, "holds", uint],
+    [6, "unresolved", uint],
+    [7, "connection", enumOf("connection", ["online", "connecting", "offline"])],
+    [8, "installing", progress, "opt"],
+    [9, "incidents", list(incident)],
+    [10, "resyncing", resyncing, "opt"],
+    [11, "confirmedHead", confirmedHead, "opt"],
+    [12, "grant", grantInfo, "opt"],
+]);
+export const helloResult = struct("hello-result", [
+    [0, "version", version],
+    [1, "runtimeVersion", tstr],
+    [2, "sem", version],
+    [3, "collection", uuid],
+    [4, "grant", grantInfo],
+    [5, "status", syncStatus],
+    [6, "features", list(tstr)],
+    [7, "headWitness", bytes, "opt"],
+]);
+export const blobRef = struct("blob-ref", [
+    [0, "plainHash", hash],
+    [1, "size", uint],
+    [2, "blobId", b32],
+    [3, "idEpoch", uint],
+    [4, "partSize", uint],
+]);
+export const textOrBlob = {
+    name: "text-or-blob",
+    enc: v => {
+        if (typeof v === "string")
+            return tstr.enc(v);
+        if ("form" in v) {
+            if (v.form !== "attachment")
+                throw new SchemaError("text-or-blob", "unknown arm", true);
+            return [1, attachmentContentV1.enc(v.content)];
+        }
+        return blobRef.enc(v);
+    },
+    dec: c => {
+        if (typeof c === "string")
+            return tstr.dec(c);
+        if (Array.isArray(c)) {
+            if (c.length !== 2)
+                throw new SchemaError("text-or-blob", "attachment arm must have exactly two elements");
+            if (uint.dec(c[0]) !== 1)
+                throw new SchemaError("text-or-blob", "unknown attachment arm", true);
+            return { form: "attachment", content: attachmentContentV1.dec(c[1]) };
+        }
+        return blobRef.dec(c);
+    },
+};
+export const HOLD_REASONS = [
+    "conflict",
+    "unknown_provenance",
+    "deleted_elsewhere",
+    "read_only",
+    "editor_busy",
+    "suspect_write",
+];
+export const holdReason = enumOf("hold-reason", HOLD_REASONS);
+export const holdRef = struct("hold-ref", [
+    [0, "id", uuid],
+    [1, "reason", holdReason],
+]);
+export const hold = struct("hold", [
+    [0, "id", uuid],
+    [1, "path", tstr],
+    [2, "reason", holdReason],
+    [3, "since", int],
+    [4, "base", textOrBlob, "opt"],
+    [5, "mine", textOrBlob],
+    [6, "theirs", textOrBlob, "opt"],
+    [7, "saves", uint],
+]);
+export const HOLD_RESOLUTIONS = ["keep_mine", "take_theirs", "use", "delete", "keep_both"];
+export const holdResolution = enumOf("hold-resolution", HOLD_RESOLUTIONS);
+export const recordState = struct("record-state", [
+    [0, "state", enumOf("confirmation", ["confirmed", "pending"])],
+    [1, "confirmedSeq", uint],
+    [2, "hold", holdRef, "opt"],
+    [3, "unresolved", uint, "opt"],
+]);
+export const linkResolution = struct("link-resolution", [
+    [0, "kind", enumOf("link-kind", ["record", "file", "ambiguous", "not_found", "invalid"])],
+    [1, "target", uuid, "opt"],
+    [2, "path", tstr, "opt"],
+]);
+export const linkView = struct("link-view", [
+    [0, "raw", tstr],
+    [1, "embed", bool],
+    [2, "resolution", linkResolution],
+    [3, "field", tstr, "opt"],
+]);
+export const authorRef = struct("author-ref", [
+    [0, "account", uuid],
+    [1, "device", uuid],
+    [2, "grant", uuid, "opt"],
+    [3, "grantAccount", uuid, "opt"],
+]);
+export const fmMap = dataMap(value);
+export const recordView = struct("record-view", [
+    [0, "id", uuid],
+    [1, "path", tstr],
+    [2, "revision", hash],
+    [3, "frontmatter", fmMap],
+    [4, "effective", fmMap, "opt"],
+    [5, "body", tstr, "opt"],
+    [6, "document", tstr, "opt"],
+    [7, "types", list(tstr)],
+    [8, "state", recordState],
+    [9, "diagnostics", list(issue), "opt"],
+    [10, "values", fmMap, "opt"],
+    [11, "mtime", int, "opt"],
+    [12, "links", list(linkView), "opt"],
+    [13, "createdBy", authorRef, "opt"],
+    [14, "modifiedBy", authorRef, "opt"],
+]);
+export const include = struct("include", [
+    [0, "effective", bool, "opt"],
+    [1, "body", bool, "opt"],
+    [2, "document", bool, "opt"],
+    [3, "diagnostics", bool, "opt"],
+    [4, "links", bool, "opt"],
+]);
+export const viewRef = struct("view-ref", [
+    [0, "path", tstr],
+    [1, "view", tstr],
+]);
+export const queryGroup = struct("query-group", [
+    [0, "values", fmMap],
+    [1, "count", uint],
+    [2, "summaries", fmMap, "opt"],
+]);
+export const queryMetadata = struct("query-metadata", [
+    [0, "columns", list(tstr), "opt"],
+    [1, "totalCount", uint, "opt"],
+    [2, "diagnostics", list(issue), "opt"],
+    [3, "view", viewRef, "opt"],
+    [4, "groups", list(queryGroup), "opt"],
+    [5, "hasMore", bool, "opt"],
+]);
+export const queryResult = struct("query-result", [
+    [0, "records", list(recordView)],
+    [1, "cursor", tstr, "opt"],
+    [2, "complete", bool],
+    [3, "asOf", uint],
+    [4, "columns", list(tstr), "opt"],
+    [5, "totalCount", uint, "opt"],
+    [6, "diagnostics", list(issue), "opt"],
+    [7, "view", viewRef, "opt"],
+    [8, "groups", list(queryGroup), "opt"],
+    [9, "hasMore", bool, "opt"],
+]);
+export const queryUpdate = struct("query-update", [
+    [0, "sub", uint],
+    [1, "kind", enumOf("update-kind", ["snapshot", "diff", "reset"])],
+    [2, "added", list(recordView), "opt"],
+    [3, "changed", list(recordView), "opt"],
+    [4, "removed", list(uuid), "opt"],
+    [5, "order", list(uuid), "opt"],
+    [6, "complete", bool],
+    [7, "asOf", uint],
+    [8, "metadata", queryMetadata, "opt"],
+]);
+export const change = struct("change", [
+    [0, "id", uuid],
+    [1, "path", tstr],
+    [2, "kind", enumOf("change-kind", ["put", "remove"])],
+    [3, "version", uint],
+    [4, "author", authorRef, "opt"],
+    [5, "entity", enumOf("change-entity", ["record", "file"]), "opt"],
+    [6, "types", list(tstr), "opt"],
+]);
+export const changesResult = struct("changes-result", [
+    [0, "changes", list(change)],
+    [1, "cursor", tstr],
+    [2, "reset", bool],
+]);
+// ------------------------------------------------------------------ operations (intent.md §3)
+export const MEDIA_CLASSES = ["image", "audio", "video", "pdf", "other"];
+export const mediaClass = enumOf("media-class", MEDIA_CLASSES);
+export const conflictMode = enumOf("conflict-mode", ["record", "reject"]);
+export const baseField = {
+    name: "base-field",
+    enc: (v) => (v.observed === undefined ? [v.key] : [v.key, value.enc(v.observed)]),
+    dec: (c) => {
+        if (!Array.isArray(c) || c.length < 1 || c.length > 2) {
+            throw new SchemaError("base-field", "must have 1 or 2 elements");
+        }
+        return c.length === 1 ? { key: tstr.dec(c[0]) } : { key: tstr.dec(c[0]), observed: value.dec(c[1]) };
+    },
+};
+export const bodyEdit = tuple("body-edit", [uint, uint, tstr]);
+export const docVersion = struct("doc-version", [
+    [0, "path", tstr],
+    [1, "doc", tstr],
+]);
+export const fileInclusion = struct("file-inclusion", [
+    [0, "include", list(mediaClass)],
+    [1, "exclude", list(tstr), "opt"],
+    [2, "maxSize", uint, "opt"],
+]);
+const listsByField = dataMap(list(value));
+export const op = union("op", [
+    [
+        1,
+        "create",
+        [
+            [1, "id", uuid],
+            [2, "path", tstr, "opt"],
+            [3, "type", tstr, "opt"],
+            [4, "frontmatter", fmMap, "opt"],
+            [5, "body", tstr, "opt"],
+            [6, "document", tstr, "opt"],
+        ],
+    ],
+    [
+        2,
+        "update",
+        [
+            [1, "id", uuid],
+            [2, "patch", fmMap, "opt"],
+            [3, "unset", list(tstr), "opt1"],
+            [4, "add", listsByField, "opt"],
+            [5, "remove", listsByField, "opt"],
+            [6, "body", tstr, "opt"],
+            [7, "bodyEdits", list(bodyEdit), "opt1"],
+            [8, "bodyBase", hash, "opt"],
+            [9, "bodyBaseText", tstr, "opt"],
+            [10, "base", list(baseField), "opt1"],
+            [11, "ifRevision", hash, "opt"],
+            [12, "updateRefs", bool, "opt"],
+        ],
+    ],
+    [
+        3,
+        "document",
+        [
+            [1, "id", uuid],
+            [2, "base", docVersion, "opt"],
+            [3, "new", docVersion, "opt"],
+            [4, "ifRevision", hash, "opt"],
+        ],
+    ],
+    [
+        4,
+        "delete",
+        [
+            [1, "id", uuid],
+            [2, "baseRevision", hash, "opt"],
+            [3, "ifRevision", hash, "opt"],
+        ],
+    ],
+    [
+        5,
+        "rename",
+        [
+            [1, "id", uuid],
+            [2, "from", tstr],
+            [3, "to", tstr],
+            [4, "updateRefs", bool],
+            [5, "ifRevision", hash, "opt"],
+        ],
+    ],
+    [
+        6,
+        "resource_put",
+        [
+            [1, "path", tstr],
+            [2, "doc", tstr],
+            [3, "baseRevision", hash, "opt"],
+            // The path must hold no resource (S-class; conflict/path_taken otherwise).
+            [4, "mustNotExist", bool, "opt"],
+        ],
+    ],
+    [
+        7,
+        "resource_delete",
+        [
+            [1, "path", tstr],
+            [2, "baseRevision", hash, "opt"],
+        ],
+    ],
+    [
+        8,
+        "file_put",
+        [
+            [1, "id", uuid],
+            [2, "path", tstr],
+            [3, "blob", blobRef],
+            [4, "ifRevision", hash, "opt"],
+            [5, "base", hash, "opt"],
+        ],
+    ],
+    [
+        9,
+        "file_delete",
+        [
+            [1, "id", uuid],
+            [2, "ifRevision", hash, "opt"],
+            [3, "base", hash, "opt"],
+        ],
+    ],
+    [
+        10,
+        "file_move",
+        [
+            [1, "id", uuid],
+            [2, "from", tstr],
+            [3, "to", tstr],
+            [4, "updateRefs", bool],
+            [5, "ifRevision", hash, "opt"],
+        ],
+    ],
+    [
+        11,
+        "conflict_dismiss",
+        [
+            [1, "mutation", uuid],
+            [2, "record", uuid],
+        ],
+    ],
+    [12, "sync_settings", [[1, "inclusion", fileInclusion]]],
+]);
+export const submitParams = struct("submit-params", [
+    [0, "ops", list(op, { nonEmpty: true }), "req1"],
+    [1, "mutationId", uuid, "opt"],
+    [2, "conflictMode", conflictMode, "opt"],
+    [3, "timezone", tstr, "opt"],
+    [4, "allowPartial", bool, "opt"],
+    [5, "mutationIds", list(uuid), "opt1"],
+    [6, "dryRun", bool, "opt"],
+    [7, "include", include, "opt"],
+    [8, "wait", enumOf("wait-for", ["pending", "confirmed", "published"]), "opt"],
+]);
+const CONFLICT_FORMS = ["missing", "value", "text", "blob", "deleted"];
+export const conflictValue = {
+    name: "conflict-value",
+    enc: (v) => {
+        switch (v.form) {
+            case "missing":
+                return [0];
+            case "value":
+                return [1, value.enc(v.value)];
+            case "text":
+                return [2, v.text];
+            case "blob":
+                return [3, blobRef.enc(v.blob)];
+            case "deleted":
+                return [4];
+        }
+    },
+    dec: (c) => {
+        if (!Array.isArray(c) || c.length === 0)
+            throw new SchemaError("conflict-value", "malformed conflict value");
+        const t = c[0];
+        if (typeof t !== "number")
+            throw new SchemaError("conflict-value", "malformed conflict value");
+        if (t > 4)
+            throw new SchemaError("conflict-value", `unknown variant ${t}`, true);
+        const form = CONFLICT_FORMS[t];
+        if (form === "missing" || form === "deleted") {
+            if (c.length !== 1)
+                throw new SchemaError("conflict-value", "malformed conflict value");
+            return { form };
+        }
+        if (c.length !== 2)
+            throw new SchemaError("conflict-value", "malformed conflict value");
+        if (form === "value")
+            return { form, value: value.dec(c[1]) };
+        if (form === "text") {
+            // Inside a log entry a text may be a text-table index; clients only see strings.
+            return { form, text: tstr.dec(c[1]) };
+        }
+        return { form, blob: blobRef.dec(c[1]) };
+    },
+};
+export const conflict = struct("conflict", [
+    [
+        0,
+        "kind",
+        // Wire values start at 1.
+        enumOf("conflict-kind", ["field", "frontmatter", "body", "path", "delete", "file"], 1),
+    ],
+    [1, "id", uuid],
+    [2, "field", tstr, "opt"],
+    [3, "base", conflictValue, "opt"],
+    [4, "kept", conflictValue],
+    [5, "lost", conflictValue],
+]);
+export const publishState = enumOf("publish-state", ["publishing", "published", "not_published"]);
+export const preflight = struct("preflight", [
+    [
+        0,
+        "rewrites",
+        list(struct("link-rewrite", [
+            [0, "record", uuid],
+            [1, "path", tstr],
+            [2, "from", tstr],
+            [3, "to", tstr],
+            [4, "field", tstr, "opt"],
+        ])),
+    ],
+    [
+        1,
+        "broken",
+        list(struct("broken-link", [
+            [0, "record", uuid],
+            [1, "path", tstr],
+            [2, "raw", tstr],
+            [3, "target", uuid],
+            [4, "field", tstr, "opt"],
+        ])),
+    ],
+]);
+export const receipt = struct("receipt", [
+    [0, "mutation", uuid],
+    [1, "state", enumOf("receipt-state", ["pending", "confirmed", "rejected", "unknown"])],
+    [2, "seq", uint, "opt"],
+    [3, "status", enumOf("status", ["applied", "merged", "conflicted"]), "opt"],
+    [4, "conflicts", list(conflict), "opt1"],
+    [5, "records", list(recordView), "opt"],
+    [6, "problem", problem, "opt"],
+    [7, "published", publishState, "opt"],
+    [8, "preflight", preflight, "opt"],
+    [9, "relocatedFrom", uint, "opt"],
+]);
+export const submitResult = list(receipt, { nonEmpty: true });
+export const conflictEntry = struct("conflict-entry", [
+    [0, "mutation", uuid],
+    [1, "seq", uint],
+    [2, "conflict", conflict],
+]);
+const fileContentProfile = enumOf("file-content-profile", [
+    "ordinary_blob", "ordinary_attachment_v1",
+    "unindexed_markdown_blob", "unindexed_markdown_attachment_v1",
+]);
+const knownFileView = struct("file-view", [
+    [0, "id", uuid],
+    [1, "path", tstr],
+    [2, "size", uint],
+    [3, "digest", hash],
+    [4, "media", mediaClass],
+    [5, "state", enumOf("file-state", ["materialized", "remote", "fetching", "pending_upload"])],
+    [6, "confirmedSeq", uint],
+    [7, "hold", holdRef, "opt"],
+    [8, "mtime", int, "opt"],
+    [9, "mediaType", tstr, "opt"],
+    [10, "contentProfile", fileContentProfile, "opt"],
+]);
+/** A future optional profile is unknown metadata, not an unreadable FileView. */
+export const fileView = {
+    ...knownFileView,
+    dec(c) {
+        const fields = c instanceof Map ? c : undefined;
+        if (fields?.has(10)) {
+            try {
+                fileContentProfile.dec(fields.get(10));
+            }
+            catch (error) {
+                if (!(error instanceof SchemaError) || !error.unknown)
+                    throw error;
+                // Do not mutate the caller's map or suppress malformed/required fields.
+                const withoutProfile = new Map(fields);
+                withoutProfile.delete(10);
+                return knownFileView.dec(withoutProfile);
+            }
+        }
+        return knownFileView.dec(c);
+    },
+};
+export const listFilesResult = struct("list-files-result", [
+    [0, "files", list(fileView)],
+    [1, "cursor", tstr, "opt"],
+    [2, "complete", bool],
+]);
+export const openUploadParams = struct("open-upload-params", [
+    [0, "transfer", uuid],
+    [1, "path", tstr],
+    [2, "size", uint],
+    [3, "digest", hash, "opt"],
+    [4, "fileId", uuid, "opt"],
+    [5, "ifRevision", hash, "opt"],
+    [6, "mutationId", uuid, "opt"],
+]);
+export const openUploadResult = struct("open-upload-result", [
+    [0, "transfer", uuid],
+    [1, "chunkSize", uint],
+    [2, "received", list(uint)],
+    [3, "expiresAt", int],
+    [4, "fileId", uuid, "opt"],
+]);
+export const uploadChunkParams = struct("upload-chunk-params", [
+    [0, "transfer", uuid],
+    [1, "index", uint],
+    [2, "bytes", { name: "bstr", enc: (v) => v, dec: (c) => (c instanceof Uint8Array ? c : bad("bstr")) }],
+]);
+function bad(ty) {
+    throw new SchemaError(ty, "wrong type");
+}
+export const fileChunk = struct("file-chunk", [
+    [0, "stream", uint],
+    [1, "offset", uint],
+    [2, "bytes", { name: "bstr", enc: (v) => v, dec: (c) => (c instanceof Uint8Array ? c : bad("bstr")) }],
+    [3, "last", bool],
+]);
+export const TRANSFER_PHASES = [
+    "receiving",
+    "sealing",
+    "uploading",
+    "appending",
+    "confirmed",
+    "fetching",
+    "streaming",
+    "done",
+];
+export const transferProgress = struct("transfer-progress", [
+    [
+        0,
+        "id",
+        either("transfer-id", uuid, (v) => typeof v === "string", (c) => c instanceof Uint8Array, uint),
+    ],
+    [1, "phase", enumOf("phase", TRANSFER_PHASES)],
+    [2, "done", uint],
+    [3, "total", uint],
+]);
+export const materialization = struct("materialization", [
+    [0, "mode", enumOf("materialize-mode", ["all", "on_demand"])],
+    [1, "pinned", list(tstr), "opt"],
+    [2, "media", list(mediaClass), "opt"],
+    [3, "maxSize", uint, "opt"],
+]);
+export const peer = struct("peer", [
+    [0, "session", b16],
+    [1, "account", uuid, "opt"],
+    [2, "app", tstr, "opt"],
+    [3, "state", value],
+    [4, "lastSeen", int],
+]);
+export const presencePush = struct("presence", [
+    [0, "record", uuid],
+    [1, "peers", list(peer)],
+]);
+export const fenceApply = struct("fence-apply", [
+    [0, "path", tstr],
+    [1, "base", hash],
+    [2, "edits", list(bodyEdit, { nonEmpty: true }), "req1"],
+    [3, "expected", hash],
+]);
+export const fenceReport = struct("fence-report", [
+    [
+        0,
+        "open",
+        list(struct("fence-open", [
+            [0, "path", tstr],
+            [1, "dirty", bool],
+            [2, "buffer", hash],
+        ])),
+    ],
+]);
+export const fenceResult = struct("fence-result", [
+    [0, "outcome", enumOf("fence-outcome", ["applied", "not_open", "buffer_changed"])],
+    [1, "buffer", tstr, "opt"],
+]);
+/** Codecs for the push types of the API, keyed by push type. */
+export const PUSH_CODECS = {
+    query_update: queryUpdate,
+    receipt,
+    status: syncStatus,
+    holds: list(hold),
+    conflicts: list(conflictEntry),
+    presence: presencePush,
+    file_chunk: fileChunk,
+    transfer_progress: transferProgress,
+    changes: changesResult,
+};
+export { b16, b32 };
+export const opClock = struct("op-clock", [
+    [0, "instant", int], [1, "tz", tstr], [2, "localDate", tstr],
+]);
+/**
+ * A captured mutation. Clients never build these (the replica captures them); the
+ * codec exists so the SDK runs the `conformance/wire/mutation/` fixtures.
+ */
+export const mutation = struct("mutation", [
+    [0, "id", uuid],
+    [1, "origin", uuid],
+    [2, "baseSeq", uint],
+    [
+        3,
+        "clock",
+        opClock,
+    ],
+    [4, "seed", b32],
+    [5, "source", enumOf("source", ["api", "external"])],
+    [6, "ops", list(op, { nonEmpty: true }), "req1"],
+    [7, "onBehalf", uuid, "opt"],
+    [8, "conflictMode", conflictMode, "opt"],
+    [9, "validatedAt", enumOf("level", ["off", "warn", "error"]), "opt"],
+    [
+        10,
+        "room",
+        struct("room-checkpoint", [
+            [0, "stream", b16],
+            [1, "state", hash],
+        ]),
+        "opt",
+    ],
+]);
+// ------------------------------------------------------------------ definitions, views, links, pending
+const confirmation = enumOf("confirmation", ["confirmed", "pending"]);
+export const resourceView = struct("resource-view", [
+    [0, "path", tstr],
+    [1, "revision", hash],
+    [2, "size", uint],
+    [3, "state", confirmation],
+    [4, "text", tstr, "opt"],
+]);
+export const listResourcesResult = struct("list-resources-result", [
+    [0, "resources", list(resourceView)],
+    [1, "complete", bool],
+    [2, "cursor", tstr, "opt"],
+]);
+export const backlinksResult = struct("backlinks-result", [
+    [
+        0,
+        "backlinks",
+        list(struct("backlink", [
+            [0, "record", recordView],
+            [1, "links", list(linkView, { nonEmpty: true }), "req1"],
+        ])),
+    ],
+    [1, "cursor", tstr, "opt"],
+    [2, "complete", bool],
+    [3, "asOf", uint],
+]);
+export const listViewsResult = struct("list-views-result", [
+    [
+        0,
+        "sources",
+        list(struct("view-source", [
+            [0, "record", uuid],
+            [1, "id", tstr],
+            [2, "name", tstr],
+            [
+                3,
+                "source",
+                struct("view-source-ref", [
+                    [0, "path", tstr],
+                    [1, "format", tstr],
+                    [2, "revision", hash],
+                    [3, "writable", bool],
+                ]),
+            ],
+            [
+                4,
+                "views",
+                list(struct("view-descriptor", [
+                    [0, "id", tstr],
+                    [1, "name", tstr],
+                    [
+                        2,
+                        "properties",
+                        list(struct("view-property", [
+                            [0, "key", tstr],
+                            [1, "label", tstr, "opt"],
+                            [2, "description", tstr, "opt"],
+                            [3, "format", tstr, "opt"],
+                            [4, "hidden", bool, "opt"],
+                        ])),
+                    ],
+                    [3, "presentation", value, "opt"],
+                ])),
+            ],
+        ])),
+    ],
+    [1, "diagnostics", list(issue)],
+    [2, "complete", bool],
+]);
+export const viewSourceDocument = struct("view-source-document", [
+    [0, "path", tstr],
+    [1, "format", tstr],
+    [2, "revision", hash],
+    [3, "document", tstr],
+    [4, "record", uuid],
+]);
+export const newTypeFile = struct("new-type-file", [
+    [0, "name", tstr],
+    [1, "path", tstr],
+]);
+export const describeResult = struct("describe-result", [
+    [0, "specVersion", tstr],
+    [
+        1,
+        "types",
+        list(struct("type-summary", [
+            [0, "name", tstr],
+            [1, "path", tstr],
+            [
+                2,
+                "implements",
+                list(struct("implementation", [
+                    [0, "contract", tstr],
+                    [1, "version", tstr],
+                    [2, "fields", dataMap(tstr)],
+                    [3, "binding", value, "opt"],
+                    [4, "digest", hash, "opt"],
+                ])),
+            ],
+            [3, "version", int, "opt"],
+            [4, "revision", hash, "opt"],
+            [5, "definition", value, "opt"],
+            [6, "schema", value, "opt"],
+        ])),
+    ],
+    [2, "settings", value],
+    [3, "inclusion", fileInclusion],
+    [4, "issues", list(issue)],
+    [
+        5,
+        "contracts",
+        list(struct("contract-summary", [
+            [0, "id", tstr],
+            [1, "version", tstr],
+            [2, "path", tstr],
+            [3, "digest", hash],
+            [4, "contractType", tstr],
+            [5, "implementedBy", list(tstr)],
+            [6, "schemas", dataMap(value), "opt"],
+        ])),
+    ],
+]);
+// Defer the cross-family codec reference until use: either wire family can be
+// imported first. This does not widen the legacy op or Submit codecs.
+const pendingOp = {
+    name: "pending-runtime-op",
+    enc: v => runtimeOp.enc(v),
+    dec: c => runtimeOp.dec(c),
+};
+export const listPendingResult = struct("list-pending-result", [
+    [
+        0,
+        "pending",
+        list(struct("pending-mutation", [
+            [0, "receipt", receipt],
+            [1, "captured", int],
+            [2, "ops", list(pendingOp, { nonEmpty: true }), "req1"],
+        ])),
+    ],
+    [1, "next", uuid, "opt"],
+]);
+/** A record or file by ID (uuid bytes) or path (text). */
+export const target = {
+    name: "target",
+    enc: (v) => (typeof v === "string" ? uuid.enc(v) : v.path),
+    dec: (c) => (typeof c === "string" ? { path: c } : uuid.dec(c)),
+};
+export const queryParams = struct("query-params", [
+    [0, "query", value],
+    [1, "include", include, "opt"],
+    [2, "contract", tstr, "opt"],
+]);
+export const executeViewParams = struct("execute-view-params", [
+    [0, "source", target],
+    [1, "view", tstr],
+    [2, "context", target, "opt"],
+    [3, "limit", uint, "opt"],
+    [4, "offset", uint, "opt"],
+    [5, "timezone", tstr, "opt"],
+    [6, "include", include, "opt"],
+]);
+// ------------------------------------------------------------------ describe_typing
+/**
+ * Core's `temporal_hint`: `date` / `date_time` only when every requested type declares
+ * the same `format` at that top-level field; any unknown type, nested path or
+ * disagreement is `none`. Plain strings stay text even if they look like dates.
+ */
+export const TEMPORAL_HINTS = ["none", "date", "date_time"];
+export const temporalHint = enumOf("temporal-hint", TEMPORAL_HINTS);
+export const typingEntry = struct("typing-entry", [
+    [0, "path", tstr],
+    [1, "hint", temporalHint],
+]);
+export const describeTypingResult = struct("describe-typing-result", [
+    [0, "catalogGeneration", uint],
+    [1, "fields", list(typingEntry)],
+]);
+/** Request bounds (`too_large` beyond them on the replica; refused locally first). */
+export const DESCRIBE_TYPING_MAX_TYPES = 64;
+export const DESCRIBE_TYPING_MAX_PATHS = 256;
+//# sourceMappingURL=wire.js.map