@seed-hypermedia/client 0.0.1

package/dist/index.mjs

@@ -0,0 +1,891 @@
+import {
+  HMActionSchema,
+  HMRequestSchema,
+  HYPERMEDIA_SCHEME,
+  entityQueryPathToHmIdPath,
+  getHMQueryString,
+  hmIdPathToEntityQueryPath,
+  packBaseId,
+  packHmId,
+  serializeBlockRange
+} from "./chunk-YUKHBJYL.mjs";
+
+// src/change.ts
+import { decode as cborDecode, encode as cborEncode3 } from "@ipld/dag-cbor";
+import { CID as CID2 } from "multiformats";
+import * as Block from "multiformats/block";
+import { sha256 } from "multiformats/hashes/sha2";
+
+// src/ref.ts
+import { encode as cborEncode2 } from "@ipld/dag-cbor";
+import { CID } from "multiformats";
+import { base58btc } from "multiformats/bases/base58";
+
+// src/signing.ts
+import { encode as cborEncode } from "@ipld/dag-cbor";
+var cborCodec = {
+  code: 113,
+  encode: (input) => cborEncode(input),
+  name: "DAG-CBOR"
+};
+function normalizeBytes(data) {
+  const normalized = new Uint8Array(data.byteLength);
+  normalized.set(data);
+  return normalized;
+}
+async function signObject(signer, data) {
+  return await signer.sign(cborEncode(data));
+}
+function toPublishInput(blobData, extraBlobs) {
+  return {
+    blobs: [
+      { data: normalizeBytes(blobData) },
+      ...(extraBlobs || []).map((b) => ({
+        ...b.cid ? { cid: b.cid } : {},
+        data: normalizeBytes(b.data)
+      }))
+    ]
+  };
+}
+
+// src/ref.ts
+function bytesEqual(a, b) {
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) {
+    if (a[i] !== b[i]) return false;
+  }
+  return true;
+}
+function buildUnsignedRef({
+  signerKey,
+  space,
+  path,
+  genesis,
+  generation,
+  capability
+}) {
+  const signerBytes = new Uint8Array(signerKey);
+  const spaceBytes = new Uint8Array(base58btc.decode(space));
+  const unsigned = {
+    type: "Ref",
+    signer: signerBytes,
+    ts: BigInt(Date.now()),
+    sig: new Uint8Array(64),
+    genesisBlob: CID.parse(genesis),
+    generation
+  };
+  if (!bytesEqual(spaceBytes, signerBytes)) {
+    unsigned.space = spaceBytes;
+  }
+  if (path) {
+    unsigned.path = path;
+  }
+  if (capability) {
+    unsigned.capability = CID.parse(capability);
+  }
+  return unsigned;
+}
+async function createVersionRef(input, signer) {
+  const signerKey = await signer.getPublicKey();
+  const unsigned = buildUnsignedRef({
+    signerKey,
+    space: input.space,
+    path: input.path,
+    genesis: input.genesis,
+    generation: input.generation,
+    capability: input.capability
+  });
+  unsigned.heads = input.version.split(".").map((v) => CID.parse(v));
+  unsigned.sig = await signObject(signer, unsigned);
+  return toPublishInput(cborEncode2(unsigned));
+}
+async function createTombstoneRef(input, signer) {
+  const signerKey = await signer.getPublicKey();
+  const unsigned = buildUnsignedRef({
+    signerKey,
+    space: input.space,
+    path: input.path,
+    genesis: input.genesis,
+    generation: input.generation,
+    capability: input.capability
+  });
+  unsigned.heads = [];
+  unsigned.sig = await signObject(signer, unsigned);
+  return toPublishInput(cborEncode2(unsigned));
+}
+async function createRedirectRef(input, signer) {
+  const signerKey = await signer.getPublicKey();
+  const unsigned = buildUnsignedRef({
+    signerKey,
+    space: input.space,
+    path: input.path,
+    genesis: input.genesis,
+    generation: input.generation,
+    capability: input.capability
+  });
+  unsigned.heads = [];
+  const redirect = {
+    path: input.targetPath
+  };
+  if (input.targetSpace && input.targetSpace !== input.space) {
+    redirect.space = new Uint8Array(base58btc.decode(input.targetSpace));
+  }
+  if (input.republish) {
+    redirect.republish = true;
+  }
+  unsigned.redirect = redirect;
+  unsigned.sig = await signObject(signer, unsigned);
+  return toPublishInput(cborEncode2(unsigned));
+}
+
+// src/change.ts
+function createChangeOps(input) {
+  const ts = input.ts ?? BigInt(Date.now());
+  const unsigned = {
+    type: "Change",
+    body: {
+      ops: input.ops,
+      opCount: input.ops.length
+    },
+    signer: null,
+    ts,
+    sig: null,
+    genesis: input.genesisCid,
+    deps: input.deps,
+    depth: input.depth
+  };
+  return { unsignedBytes: cborEncode3(unsigned), ts };
+}
+async function createChange(unsignedBytes, signer) {
+  const change = cborDecode(unsignedBytes);
+  const genesis = change.genesis instanceof CID2 ? change.genesis : null;
+  change.signer = new Uint8Array(await signer.getPublicKey());
+  change.sig = new Uint8Array(64);
+  change.sig = await signer.sign(cborEncode3(change));
+  const block = await Block.encode({ value: change, codec: cborCodec, hasher: sha256 });
+  return { bytes: block.bytes, cid: block.cid, genesis };
+}
+var signPreparedChange = async (unsignedBytes, signer) => {
+  const result = await createChange(unsignedBytes, signer);
+  return { signedBytes: result.bytes, cid: result.cid, genesis: result.genesis };
+};
+async function createGenesisChange(signer) {
+  const pubKey = await signer.getPublicKey();
+  const unsigned = {
+    type: "Change",
+    signer: new Uint8Array(pubKey),
+    sig: new Uint8Array(64),
+    ts: BigInt(0)
+  };
+  unsigned.sig = await signer.sign(cborEncode3(unsigned));
+  const block = await Block.encode({ value: unsigned, codec: cborCodec, hasher: sha256 });
+  return { bytes: block.bytes, cid: block.cid };
+}
+async function createDocumentChangeFromOps(input, signer) {
+  const { unsignedBytes, ts } = createChangeOps(input);
+  const { bytes, cid } = await createChange(unsignedBytes, signer);
+  return { bytes, cid, ts };
+}
+async function createDocumentChange(input, signer) {
+  const ops = protoChangesToOps(input.changes);
+  const { unsignedBytes } = createChangeOps({ ops, genesisCid: input.genesisCid, deps: input.deps, depth: input.depth });
+  const { bytes, cid } = await createChange(unsignedBytes, signer);
+  return { bytes, cid };
+}
+function protoChangesToOps(changes) {
+  return changes.map((change) => {
+    const op = change.op;
+    if (!op || !op.case) throw new Error("Invalid change: missing op");
+    switch (op.case) {
+      case "setMetadata":
+        return {
+          type: "SetAttributes",
+          attrs: [{ key: [op.value.key], value: op.value.value }]
+        };
+      default:
+        throw new Error(
+          `Op "${op.case}" is not supported for client-side change creation. Use PrepareDocumentChange + createChange instead.`
+        );
+    }
+  });
+}
+async function signDocumentChange(input, signer) {
+  const { bytes: signedBytes, cid: changeCid, genesis: changeGenesis } = await createChange(input.unsignedChange, signer);
+  const effectiveGenesis = input.genesis || (changeGenesis ? changeGenesis.toString() : changeCid.toString());
+  const effectiveGeneration = input.generation != null ? Number(input.generation) : Date.now();
+  const refBlobs = await createVersionRef(
+    {
+      space: input.account,
+      path: input.path ?? "",
+      genesis: effectiveGenesis,
+      version: changeCid.toString(),
+      generation: effectiveGeneration,
+      capability: input.capability
+    },
+    signer
+  );
+  return {
+    changeCid,
+    publishInput: {
+      blobs: [{ data: normalizeBytes(signedBytes), cid: changeCid.toString() }, ...refBlobs.blobs]
+    }
+  };
+}
+
+// src/client.ts
+import { encode as cborEncode4 } from "@ipld/dag-cbor";
+import { deserialize } from "superjson";
+
+// src/errors.ts
+var SeedClientError = class extends Error {
+  status;
+  body;
+  constructor(message, status, body) {
+    super(message);
+    this.name = "SeedClientError";
+    this.status = status;
+    this.body = body;
+  }
+};
+var SeedNetworkError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "SeedNetworkError";
+  }
+};
+var SeedValidationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "SeedValidationError";
+  }
+};
+
+// src/client.ts
+var PRIMITIVE_VALUE_KEY = "__value";
+function serializeQueryString(data, _schema) {
+  const params = new URLSearchParams();
+  if (typeof data !== "object" || data === null) {
+    if (data !== void 0 && data !== null) {
+      params.append(PRIMITIVE_VALUE_KEY, String(data));
+    }
+    const queryString2 = params.toString();
+    return queryString2 ? `?${queryString2}` : "";
+  }
+  for (const [key, value] of Object.entries(data)) {
+    if (value === void 0 || value === null) {
+      continue;
+    }
+    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+      params.append(key, String(value));
+    } else {
+      params.append(key, JSON.stringify(value));
+    }
+  }
+  const queryString = params.toString();
+  return queryString ? `?${queryString}` : "";
+}
+var QUERY_PARAM_SERIALIZERS = {
+  Account: (input) => ({
+    id: input
+  }),
+  Resource: (input) => ({
+    id: packHmId(input)
+  }),
+  ResourceMetadata: (input) => ({
+    id: packHmId(input)
+  }),
+  ListCitations: (input) => ({
+    targetId: packHmId(input.targetId)
+  }),
+  ListChanges: (input) => ({
+    targetId: packHmId(input.targetId)
+  }),
+  ListCapabilities: (input) => ({
+    targetId: packHmId(input.targetId)
+  })
+};
+function createSeedClient(baseUrl, options) {
+  const normalizedBaseUrl = baseUrl.replace(/\/+$/, "");
+  const fetchFn = (options == null ? void 0 : options.fetch) ?? globalThis.fetch;
+  const defaultHeaders = (options == null ? void 0 : options.headers) ?? {};
+  async function request(key, input) {
+    const requestSchema = HMRequestSchema.options.find((schema) => schema.shape.key.value === key);
+    if (!requestSchema) {
+      throw new SeedValidationError(`Unknown request key: ${key}`);
+    }
+    let validatedInput;
+    try {
+      validatedInput = requestSchema.shape.input.parse(input);
+    } catch (err) {
+      throw new SeedValidationError(`Invalid input for ${key}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    let response;
+    const isAction = HMActionSchema.options.some((s) => s.shape.key.value === key);
+    if (isAction) {
+      const url = `${normalizedBaseUrl}/api/${key}`;
+      try {
+        response = await fetchFn(url, {
+          method: "POST",
+          headers: {
+            Accept: "application/json",
+            "Content-Type": "application/cbor",
+            ...defaultHeaders
+          },
+          body: new Uint8Array(cborEncode4(stripUndefined(validatedInput)))
+        });
+      } catch (err) {
+        throw new SeedNetworkError(
+          `Network error fetching ${key}: ${err instanceof Error ? err.message : String(err)}`,
+          { cause: err }
+        );
+      }
+    } else {
+      const inputToParams = QUERY_PARAM_SERIALIZERS[key];
+      let queryString;
+      if (inputToParams) {
+        const params = inputToParams(validatedInput);
+        const searchParams = new URLSearchParams(params);
+        queryString = searchParams.toString() ? `?${searchParams.toString()}` : "";
+      } else if (!validatedInput) {
+        queryString = "";
+      } else {
+        queryString = serializeQueryString(validatedInput, requestSchema.shape.input);
+      }
+      const url = `${normalizedBaseUrl}/api/${key}${queryString}`;
+      try {
+        response = await fetchFn(url, {
+          method: "GET",
+          headers: {
+            Accept: "application/json",
+            ...defaultHeaders
+          }
+        });
+      } catch (err) {
+        throw new SeedNetworkError(
+          `Network error fetching ${key}: ${err instanceof Error ? err.message : String(err)}`,
+          { cause: err }
+        );
+      }
+    }
+    if (!response.ok) {
+      let errorBody;
+      try {
+        errorBody = await response.text();
+      } catch {
+      }
+      throw new SeedClientError(
+        `HTTP ${response.status} from ${key}: ${response.statusText}`,
+        response.status,
+        errorBody
+      );
+    }
+    const rawJson = await response.json();
+    const deserialized = deserialize(rawJson);
+    return requestSchema.shape.output.parse(deserialized);
+  }
+  function publish(input) {
+    return request("PublishBlobs", input);
+  }
+  async function publishDocument(input, signer) {
+    if (!input.genesis && !input.baseVersion) {
+      const genesisChange = await createGenesisChange(signer);
+      const contentChange = await createDocumentChange(
+        {
+          changes: input.changes,
+          genesisCid: genesisChange.cid,
+          deps: [genesisChange.cid],
+          depth: 1
+        },
+        signer
+      );
+      const ref = await createVersionRef(
+        {
+          space: input.account,
+          path: input.path ?? "",
+          genesis: genesisChange.cid.toString(),
+          version: contentChange.cid.toString(),
+          generation: input.generation != null ? Number(input.generation) : 1,
+          capability: input.capability
+        },
+        signer
+      );
+      await publish({
+        blobs: [
+          { data: genesisChange.bytes, cid: genesisChange.cid.toString() },
+          { data: contentChange.bytes, cid: contentChange.cid.toString() },
+          ...ref.blobs
+        ]
+      });
+      return;
+    }
+    const { unsignedChange } = await request("PrepareDocumentChange", {
+      account: input.account,
+      path: input.path,
+      baseVersion: input.baseVersion,
+      changes: input.changes,
+      capability: input.capability,
+      visibility: input.visibility
+    });
+    const { publishInput } = await signDocumentChange(
+      {
+        account: input.account,
+        path: input.path,
+        unsignedChange,
+        genesis: input.genesis,
+        generation: input.generation,
+        capability: input.capability
+      },
+      signer
+    );
+    await publish(publishInput);
+  }
+  return {
+    baseUrl: normalizedBaseUrl,
+    request,
+    publish,
+    publishBlobs: publish,
+    publishDocument
+  };
+}
+function stripUndefined(obj) {
+  if (obj === null || obj === void 0 || typeof obj !== "object") return obj;
+  if (ArrayBuffer.isView(obj) || obj instanceof ArrayBuffer) return obj;
+  if (Array.isArray(obj)) return obj.map(stripUndefined);
+  const result = {};
+  for (const [k, v] of Object.entries(obj)) {
+    if (v !== void 0) result[k] = stripUndefined(v);
+  }
+  return result;
+}
+
+// src/comment.ts
+import { encode as cborEncode5 } from "@ipld/dag-cbor";
+import { CID as CID3 } from "multiformats";
+import { base58btc as base58btc2 } from "multiformats/bases/base58";
+function trimTrailingEmptyBlocks(blocks) {
+  let end = blocks.length;
+  while (end > 0) {
+    const node = blocks[end - 1];
+    if (!isEmptyBlockNode(node)) break;
+    end--;
+  }
+  return blocks.slice(0, end);
+}
+function isEmptyBlockNode(node) {
+  const { block, children } = node;
+  if (children && children.length > 0) return false;
+  if (block.type !== "Paragraph" && block.type !== "Heading") return false;
+  return !block.text || block.text.trim() === "";
+}
+function annotationsToPublishable(annotations) {
+  return annotations.map((annotation) => {
+    const { type, starts, ends } = annotation;
+    if (type === "Bold") return { type: "Bold", starts, ends };
+    if (type === "Italic") return { type: "Italic", starts, ends };
+    if (type === "Underline") return { type: "Underline", starts, ends };
+    if (type === "Strike") return { type: "Strike", starts, ends };
+    if (type === "Code") return { type: "Code", starts, ends };
+    if (type === "Link") return { type: "Link", starts, ends, link: annotation.link || "" };
+    if (type === "Embed") return { type: "Embed", starts, ends, link: annotation.link || "" };
+    throw new Error(`Unsupported annotation type: ${type}`);
+  });
+}
+function blockToPublishable(blockNode) {
+  const block = blockNode.block;
+  if (block.type === "Paragraph") {
+    if (block.text === "" || block.text === void 0) return null;
+    return {
+      id: block.id,
+      type: "Paragraph",
+      text: block.text,
+      annotations: annotationsToPublishable(block.annotations || []),
+      ...block.attributes,
+      children: blocksToPublishable(blockNode.children || [])
+    };
+  }
+  if (block.type === "Heading") {
+    return {
+      id: block.id,
+      type: "Heading",
+      text: block.text,
+      annotations: annotationsToPublishable(block.annotations || []),
+      ...block.attributes,
+      children: blocksToPublishable(blockNode.children || [])
+    };
+  }
+  if (block.type === "Math") {
+    return {
+      id: block.id,
+      type: "Math",
+      text: block.text,
+      annotations: annotationsToPublishable(block.annotations || []),
+      ...block.attributes,
+      children: blocksToPublishable(blockNode.children || [])
+    };
+  }
+  if (block.type === "Code") {
+    return {
+      id: block.id,
+      type: "Code",
+      text: block.text,
+      annotations: annotationsToPublishable(block.annotations || []),
+      ...block.attributes,
+      children: blocksToPublishable(blockNode.children || [])
+    };
+  }
+  if (block.type === "Image") {
+    return {
+      id: block.id,
+      type: "Image",
+      text: block.text,
+      link: block.link,
+      annotations: annotationsToPublishable(block.annotations || []),
+      ...block.attributes,
+      children: blocksToPublishable(blockNode.children || [])
+    };
+  }
+  if (block.type === "Video") {
+    return {
+      id: block.id,
+      type: "Video",
+      text: "",
+      link: block.link,
+      ...block.attributes,
+      children: blocksToPublishable(blockNode.children || [])
+    };
+  }
+  if (block.type === "File") {
+    return {
+      id: block.id,
+      type: "File",
+      link: block.link,
+      ...block.attributes,
+      children: blocksToPublishable(blockNode.children || [])
+    };
+  }
+  if (block.type === "Button") {
+    return {
+      id: block.id,
+      type: "Button",
+      text: block.text,
+      link: block.link,
+      ...block.attributes,
+      children: blocksToPublishable(blockNode.children || [])
+    };
+  }
+  if (block.type === "Embed") {
+    return {
+      id: block.id,
+      type: "Embed",
+      link: block.link,
+      ...block.attributes,
+      children: blocksToPublishable(blockNode.children || [])
+    };
+  }
+  if (block.type === "WebEmbed") {
+    return {
+      id: block.id,
+      type: "WebEmbed",
+      link: block.link,
+      ...block.attributes,
+      children: blocksToPublishable(blockNode.children || [])
+    };
+  }
+  throw new Error(`Unsupported block type: ${block.type}`);
+}
+function blocksToPublishable(blockNodes) {
+  return blockNodes.map((blockNode) => {
+    const block = blockToPublishable(blockNode);
+    if (!block) return null;
+    return block;
+  }).filter((blockNode) => blockNode !== null);
+}
+function cleanContentOfUndefined(content) {
+  content.forEach((blockNode) => {
+    const { block, children } = blockNode;
+    if (typeof block.text === "undefined") block.text = "";
+    if (children) cleanContentOfUndefined(children);
+  });
+}
+function createUnsignedComment({
+  content,
+  docId,
+  docVersion,
+  signerKey,
+  replyCommentVersion,
+  rootReplyCommentVersion,
+  visibility
+}) {
+  const unsignedComment = {
+    type: "Comment",
+    body: blocksToPublishable(content),
+    space: new Uint8Array(base58btc2.decode(docId.uid)),
+    version: docVersion,
+    signer: new Uint8Array(signerKey),
+    ts: BigInt(Date.now()),
+    sig: new Uint8Array(64),
+    path: hmIdPathToEntityQueryPath(docId.path),
+    replyParent: replyCommentVersion || void 0,
+    threadRoot: rootReplyCommentVersion || void 0
+  };
+  if (!unsignedComment.replyParent) delete unsignedComment.replyParent;
+  if (!unsignedComment.threadRoot) delete unsignedComment.threadRoot;
+  if (visibility) unsignedComment.visibility = visibility;
+  return unsignedComment;
+}
+async function createSignedComment(comment, signer) {
+  const commentForSigning = {
+    ...comment,
+    version: comment.version.split(".").map((v) => CID3.parse(v))
+  };
+  if (comment.threadRoot) commentForSigning.threadRoot = CID3.parse(comment.threadRoot);
+  if (comment.replyParent) commentForSigning.replyParent = CID3.parse(comment.replyParent);
+  commentForSigning.sig = await signObject(signer, commentForSigning);
+  return commentForSigning;
+}
+async function createCommentBlob({
+  content,
+  docId,
+  docVersion,
+  signer,
+  replyCommentVersion,
+  rootReplyCommentVersion,
+  visibility
+}) {
+  const signerKey = await signer.getPublicKey();
+  cleanContentOfUndefined(content);
+  const unsignedComment = createUnsignedComment({
+    content,
+    docId,
+    docVersion,
+    signerKey,
+    replyCommentVersion,
+    rootReplyCommentVersion,
+    visibility
+  });
+  const signedComment = await createSignedComment(unsignedComment, signer);
+  return cborEncode5(signedComment);
+}
+function generateBlockId(length = 8) {
+  const characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+  let result = "";
+  for (let i = 0; i < length; i++) {
+    result += characters.charAt(Math.floor(Math.random() * characters.length));
+  }
+  return result;
+}
+function wrapQuotedContent(content, input) {
+  if (!input.quotingBlockId) return content;
+  return [
+    {
+      block: {
+        id: generateBlockId(8),
+        type: "Embed",
+        text: "",
+        attributes: {
+          childrenType: "Group",
+          view: "Content"
+        },
+        annotations: [],
+        link: packHmId({
+          ...input.docId,
+          blockRef: input.quotingBlockId,
+          version: input.docVersion
+        })
+      },
+      children: content
+    }
+  ];
+}
+async function resolveCommentContentAndBlobs(input) {
+  const defaultPrepareAttachments = async (_binaries) => ({
+    blobs: [],
+    resultCIDs: []
+  });
+  if ("getContent" in input) {
+    const { blockNodes: rawBlockNodes, blobs } = await input.getContent(
+      input.prepareAttachments || defaultPrepareAttachments
+    );
+    return {
+      content: wrapQuotedContent(trimTrailingEmptyBlocks(rawBlockNodes), input),
+      blobs
+    };
+  }
+  return {
+    content: wrapQuotedContent(trimTrailingEmptyBlocks(input.content), input),
+    blobs: input.blobs || []
+  };
+}
+async function createComment(input, signer) {
+  const { content, blobs } = await resolveCommentContentAndBlobs(input);
+  const comment = await createCommentBlob({
+    content,
+    docId: input.docId,
+    docVersion: input.docVersion,
+    signer,
+    replyCommentVersion: input.replyCommentVersion,
+    rootReplyCommentVersion: input.rootReplyCommentVersion,
+    visibility: input.visibility
+  });
+  return toPublishInput(comment, blobs);
+}
+async function deleteComment(input, signer) {
+  const parts = input.commentId.split("/");
+  const tsid = parts[1];
+  if (!tsid) {
+    throw new Error(`Invalid comment ID format: ${input.commentId}`);
+  }
+  const signerKey = await signer.getPublicKey();
+  const tombstone = {
+    type: "Comment",
+    id: tsid,
+    body: [],
+    space: new Uint8Array(base58btc2.decode(input.targetAccount)),
+    path: input.targetPath,
+    version: input.targetVersion.split(".").map((v) => CID3.parse(v)),
+    signer: new Uint8Array(signerKey),
+    ts: BigInt(Date.now()),
+    sig: new Uint8Array(64)
+  };
+  if (input.visibility) tombstone.visibility = input.visibility;
+  tombstone.sig = await signObject(signer, tombstone);
+  const encoded = cborEncode5(tombstone);
+  return toPublishInput(encoded, []);
+}
+
+// src/contact.ts
+import { encode as cborEncode6, decode as cborDecode2 } from "@ipld/dag-cbor";
+import { base58btc as base58btc3 } from "multiformats/bases/base58";
+function extractTsid(contactId) {
+  const parts = contactId.split("/");
+  const tsid = parts[1];
+  if (!tsid) {
+    throw new Error(`Invalid contact ID format: ${contactId}. Expected "authority/tsid".`);
+  }
+  return tsid;
+}
+async function computeTSID(timestampMs, blobData) {
+  const buf = new ArrayBuffer(8);
+  new DataView(buf).setBigUint64(0, timestampMs, false);
+  const tsBytes = new Uint8Array(buf, 2, 6);
+  const hashBuffer = await crypto.subtle.digest("SHA-256", blobData);
+  const hashBytes = new Uint8Array(hashBuffer, 0, 4);
+  const tsidBytes = new Uint8Array(10);
+  tsidBytes.set(tsBytes, 0);
+  tsidBytes.set(hashBytes, 6);
+  return base58btc3.encode(tsidBytes);
+}
+async function createContact(input, signer) {
+  const signerKey = await signer.getPublicKey();
+  const ts = BigInt(Date.now());
+  const unsigned = {
+    type: "Contact",
+    signer: new Uint8Array(signerKey),
+    sig: new Uint8Array(64),
+    ts,
+    subject: new Uint8Array(base58btc3.decode(input.subjectUid)),
+    name: input.name
+  };
+  unsigned.sig = await signObject(signer, unsigned);
+  const encoded = cborEncode6(unsigned);
+  const authority = base58btc3.encode(new Uint8Array(signerKey));
+  const tsid = await computeTSID(ts, encoded);
+  return {
+    ...toPublishInput(encoded),
+    recordId: `${authority}/${tsid}`
+  };
+}
+async function updateContact(input, signer) {
+  const signerKey = await signer.getPublicKey();
+  const tsid = extractTsid(input.contactId);
+  const unsigned = {
+    type: "Contact",
+    signer: new Uint8Array(signerKey),
+    sig: new Uint8Array(64),
+    ts: BigInt(Date.now()),
+    id: tsid,
+    subject: new Uint8Array(base58btc3.decode(input.subjectUid)),
+    name: input.name
+  };
+  unsigned.sig = await signObject(signer, unsigned);
+  return toPublishInput(cborEncode6(unsigned));
+}
+async function deleteContact(input, signer) {
+  const signerKey = await signer.getPublicKey();
+  const tsid = extractTsid(input.contactId);
+  const unsigned = {
+    type: "Contact",
+    signer: new Uint8Array(signerKey),
+    sig: new Uint8Array(64),
+    ts: BigInt(Date.now()),
+    id: tsid
+  };
+  unsigned.sig = await signObject(signer, unsigned);
+  return toPublishInput(cborEncode6(unsigned));
+}
+async function contactRecordIdFromBlob(blobData) {
+  const decoded = cborDecode2(blobData);
+  if (decoded.type !== "Contact") {
+    throw new Error(`Expected Contact blob, got "${decoded.type}"`);
+  }
+  const signerBytes = decoded.signer;
+  const ts = BigInt(decoded.ts);
+  const authority = base58btc3.encode(new Uint8Array(signerBytes));
+  const tsid = await computeTSID(ts, blobData);
+  return `${authority}/${tsid}`;
+}
+
+// src/capability.ts
+import { encode as cborEncode7 } from "@ipld/dag-cbor";
+import { base58btc as base58btc4 } from "multiformats/bases/base58";
+async function createCapability(input, signer) {
+  const signerKey = await signer.getPublicKey();
+  const ts = BigInt(Date.now());
+  const unsigned = {
+    type: "Capability",
+    signer: new Uint8Array(signerKey),
+    sig: new Uint8Array(64),
+    ts,
+    delegate: new Uint8Array(base58btc4.decode(input.delegateUid)),
+    role: input.role
+  };
+  if (input.path) {
+    unsigned.path = input.path;
+  }
+  if (input.label) {
+    unsigned.label = input.label;
+  }
+  unsigned.sig = await signObject(signer, unsigned);
+  return toPublishInput(cborEncode7(unsigned));
+}
+export {
+  HYPERMEDIA_SCHEME,
+  SeedClientError,
+  SeedNetworkError,
+  SeedValidationError,
+  contactRecordIdFromBlob,
+  createCapability,
+  createChange,
+  createChangeOps,
+  createComment,
+  createContact,
+  createDocumentChange,
+  createDocumentChangeFromOps,
+  createGenesisChange,
+  createRedirectRef,
+  createSeedClient,
+  createTombstoneRef,
+  createVersionRef,
+  deleteComment,
+  deleteContact,
+  entityQueryPathToHmIdPath,
+  getHMQueryString,
+  hmIdPathToEntityQueryPath,
+  packBaseId,
+  packHmId,
+  serializeBlockRange,
+  signDocumentChange,
+  signPreparedChange,
+  trimTrailingEmptyBlocks,
+  updateContact
+};