@hraness/ghostget 0.17.2

package/dist/index-26yq8q16.js

@@ -0,0 +1,31 @@
+// @bun
+// src/provider-plugin-identifiers.ts
+var PROVIDER_PLUGIN_ID_MAX_LENGTH = 63;
+var PROVIDER_PLUGIN_OPERATION_NAME_MAX_LENGTH = 163;
+var strictKebabPattern = /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/u;
+var strictKebabSegmentPattern = /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/u;
+var portableProviderPluginVersionPattern = /^(?:0|[1-9][0-9]*)\.(?:0|[1-9][0-9]*)\.(?:0|[1-9][0-9]*)(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/u;
+function isPortableProviderPluginVersion(value) {
+  if (typeof value !== "string" || value.length > 128)
+    return false;
+  const match = portableProviderPluginVersionPattern.exec(value);
+  if (match === null)
+    return false;
+  const prerelease = match[1];
+  return prerelease === undefined || prerelease.split(".").every((identifier) => !/^[0-9]+$/u.test(identifier) || identifier === "0" || !identifier.startsWith("0"));
+}
+function isProviderPluginId(value) {
+  return typeof value === "string" && value.length <= PROVIDER_PLUGIN_ID_MAX_LENGTH && strictKebabPattern.test(value);
+}
+function isProviderPluginSurfaceId(value) {
+  return isProviderPluginId(value);
+}
+function isProviderPluginOperationName(value) {
+  if (typeof value !== "string" || value.length > PROVIDER_PLUGIN_OPERATION_NAME_MAX_LENGTH) {
+    return false;
+  }
+  const segments = value.split(".");
+  return segments.length >= 2 && segments.length <= 4 && segments.every((segment) => segment.length <= 40 && strictKebabSegmentPattern.test(segment));
+}
+
+export { PROVIDER_PLUGIN_ID_MAX_LENGTH, PROVIDER_PLUGIN_OPERATION_NAME_MAX_LENGTH, isPortableProviderPluginVersion, isProviderPluginId, isProviderPluginSurfaceId, isProviderPluginOperationName };

package/dist/index-9t13b4k7.js

@@ -0,0 +1,508 @@
+// @bun
+import {
+  canonicalJson,
+  sha256
+} from "./index-gwk7rbyj.js";
+
+// src/message-like-me-agentic-messaging.ts
+import { types as nodeTypes } from "util";
+var MESSAGE_LIKE_ME_SOURCE_CONVERSATION_COORDINATE_V1_SCHEMA_VERSION = 1;
+var MESSAGE_LIKE_ME_SOURCE_CONVERSATION_COORDINATE_V1_CONTRACT_ID = "wrench.message-like-me.source-conversation-coordinate.v1";
+var GHOSTGET_MESSAGING_CONTEXT_BINDING_V1_FORMAT = "wrench.messaging-context-binding";
+var GHOSTGET_MESSAGING_CONTEXT_BINDING_V1_CONTRACT_ID = "wrench.messaging-context-binding.v1";
+var GHOSTGET_MESSAGING_CONTEXT_BINDING_V1_CONTRACT_DESCRIPTOR = Object.freeze({
+  contractId: GHOSTGET_MESSAGING_CONTEXT_BINDING_V1_CONTRACT_ID,
+  fields: Object.freeze([
+    "schemaVersion:1",
+    "format:wrench.messaging-context-binding",
+    "contractId:wrench.messaging-context-binding.v1",
+    "contractHash:sha256",
+    "routeRef:opaque",
+    "contextRef:opaque",
+    "exactDataRevision:sha256",
+    "latestMessageRevision:sha256",
+    "validatedAt:rfc3339",
+    "expiresAt:rfc3339"
+  ]),
+  format: "wrench.messaging-contract-descriptor",
+  schemaVersion: 1
+});
+var GHOSTGET_MESSAGING_CONTEXT_BINDING_V1_CONTRACT_HASH = "5e64da6a3d826e7f6fa3db7dca0a4ba92c10cfb784981e71a25aed9513a5c687";
+var GHOSTGET_MESSAGING_RECEIPT_BINDING_V1_FORMAT = "wrench.messaging-receipt-binding";
+var GHOSTGET_MESSAGING_RECEIPT_BINDING_V1_CONTRACT_ID = "wrench.messaging-receipt-binding.v1";
+var GHOSTGET_MESSAGING_RECEIPT_BINDING_V1_CONTRACT_DESCRIPTOR = Object.freeze({
+  contractId: GHOSTGET_MESSAGING_RECEIPT_BINDING_V1_CONTRACT_ID,
+  fields: Object.freeze([
+    "schemaVersion:1",
+    "format:wrench.messaging-receipt-binding",
+    "contractId:wrench.messaging-receipt-binding.v1",
+    "contractHash:sha256",
+    "clientIntentSha256:sha256",
+    "routeRefSha256:sha256",
+    "contextRefSha256:sha256",
+    "turnDigest:sha256",
+    "previewDigest:sha256",
+    "runId:opaque",
+    "state:submitted|failed|partial|indeterminate",
+    "partCount:uint",
+    "provenPartCount:uint",
+    "receiptSha256:sha256",
+    "recordedAt:rfc3339"
+  ]),
+  format: "wrench.messaging-contract-descriptor",
+  schemaVersion: 1
+});
+var GHOSTGET_MESSAGING_RECEIPT_BINDING_V1_CONTRACT_HASH = "7f6cf724f0200b2399e4f4641c637b20b48914fc5c9b13755127a8ec69fe66f4";
+var GHOSTGET_MESSAGING_CONTEXT_BINDING_V2_FORMAT = "wrench.messaging-context-binding";
+var GHOSTGET_MESSAGING_CONTEXT_BINDING_V2_CONTRACT_ID = "wrench.messaging-context-binding.v2";
+var GHOSTGET_MESSAGING_CONTEXT_BINDING_V2_CONTRACT_DESCRIPTOR = Object.freeze({
+  contractId: GHOSTGET_MESSAGING_CONTEXT_BINDING_V2_CONTRACT_ID,
+  fields: Object.freeze([
+    "schemaVersion:2",
+    "format:wrench.messaging-context-binding",
+    "contractId:wrench.messaging-context-binding.v2",
+    "contractHash:sha256",
+    "sourceConversationCoordinate:{contractId,schemaVersion,sha256}",
+    "routeRef:opaque",
+    "contextRef:opaque",
+    "exactDataRevision:sha256",
+    "latestMessageRevision:sha256",
+    "validatedAt:rfc3339",
+    "expiresAt:rfc3339"
+  ]),
+  format: "wrench.messaging-contract-descriptor",
+  schemaVersion: 2
+});
+var GHOSTGET_MESSAGING_CONTEXT_BINDING_V2_CONTRACT_HASH = sha256(canonicalJson(GHOSTGET_MESSAGING_CONTEXT_BINDING_V2_CONTRACT_DESCRIPTOR));
+var GHOSTGET_MESSAGING_RECEIPT_BINDING_V2_FORMAT = "wrench.messaging-receipt-binding";
+var GHOSTGET_MESSAGING_RECEIPT_BINDING_V2_CONTRACT_ID = "wrench.messaging-receipt-binding.v2";
+var GHOSTGET_MESSAGING_RECEIPT_BINDING_V2_CONTRACT_DESCRIPTOR = Object.freeze({
+  contractId: GHOSTGET_MESSAGING_RECEIPT_BINDING_V2_CONTRACT_ID,
+  fields: Object.freeze([
+    "schemaVersion:2",
+    "format:wrench.messaging-receipt-binding",
+    "contractId:wrench.messaging-receipt-binding.v2",
+    "contractHash:sha256",
+    "clientIntentSha256:sha256",
+    "contextBindingSha256:sha256",
+    "sourceConversationCoordinateSha256:sha256",
+    "routeRefSha256:sha256",
+    "contextRefSha256:sha256",
+    "turnDigest:sha256",
+    "previewDigest:sha256",
+    "runId:opaque",
+    "state:submitted|failed|partial|indeterminate",
+    "partCount:uint",
+    "provenPartCount:uint",
+    "receiptSha256:sha256",
+    "recordedAt:rfc3339"
+  ]),
+  format: "wrench.messaging-contract-descriptor",
+  schemaVersion: 2
+});
+var GHOSTGET_MESSAGING_RECEIPT_BINDING_V2_CONTRACT_HASH = sha256(canonicalJson(GHOSTGET_MESSAGING_RECEIPT_BINDING_V2_CONTRACT_DESCRIPTOR));
+var GHOSTGET_MESSAGING_CLIENT_INTENT_BINDING_V1_FORMAT = "wrench.messaging-client-intent-binding";
+var GHOSTGET_MESSAGING_CLIENT_INTENT_BINDING_V1_CONTRACT_ID = "wrench.messaging-client-intent-binding.v1";
+var GHOSTGET_MESSAGING_CONTEXT_INSTANCE_V1_CONTRACT_ID = "wrench.messaging-context-instance.v1";
+var GHOSTGET_MESSAGING_CONTEXT_INSTANCE_V2_CONTRACT_ID = "wrench.messaging-context-instance.v2";
+function fail(message) {
+  throw new TypeError(message);
+}
+function plainObject(value, label) {
+  if (value === null || typeof value !== "object" || Array.isArray(value) || nodeTypes.isProxy(value) || Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null)
+    return fail(`${label} must be a plain object`);
+  for (const key of Reflect.ownKeys(value)) {
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    if (typeof key !== "string" || descriptor === undefined || !("value" in descriptor) || !descriptor.enumerable)
+      return fail(`${label} must contain only enumerable string-keyed data properties`);
+  }
+  return value;
+}
+function exactKeys(value, expected, label) {
+  const actual = Object.keys(value).sort();
+  const sortedExpected = [...expected].sort();
+  if (actual.length !== sortedExpected.length || actual.some((key, index) => key !== sortedExpected[index]))
+    return fail(`${label} must contain exactly ${sortedExpected.join(", ")}`);
+}
+function isWellFormedUnicode(value) {
+  for (let index = 0;index < value.length; index += 1) {
+    const unit = value.charCodeAt(index);
+    if (unit >= 55296 && unit <= 56319) {
+      const next = value.charCodeAt(index + 1);
+      if (!(next >= 56320 && next <= 57343))
+        return false;
+      index += 1;
+    } else if (unit >= 56320 && unit <= 57343) {
+      return false;
+    }
+  }
+  return true;
+}
+function text(value, label, maximumBytes = 1024) {
+  if (typeof value !== "string" || value.length === 0 || Buffer.byteLength(value, "utf8") > maximumBytes || /\p{Cc}|\p{Zl}|\p{Zp}/u.test(value) || value !== value.trim() || !isWellFormedUnicode(value))
+    return fail(`${label} must be bounded well-formed text without controls or surrounding space`);
+  return value;
+}
+function digest(value, label) {
+  if (typeof value !== "string" || !/^[a-f0-9]{64}$/u.test(value)) {
+    return fail(`${label} must be a lowercase SHA-256 digest`);
+  }
+  return value;
+}
+function timestamp(value, label) {
+  if (typeof value !== "string" || !/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/u.test(value) || new Date(value).toISOString() !== value)
+    return fail(`${label} must be a canonical RFC 3339 timestamp`);
+  return value;
+}
+function legacyTimestamp(value, label) {
+  if (typeof value !== "string" || !/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,9})?Z$/u.test(value) || !Number.isFinite(Date.parse(value)))
+    return fail(`${label} must be an RFC 3339 UTC timestamp`);
+  return value;
+}
+function parseMessageLikeMeSourceConversationCoordinateV1(value) {
+  const source = plainObject(value, "Message Like Me source-conversation coordinate");
+  exactKeys(source, ["sourceAccountId", "sourceExternalId", "coordinate"], "Message Like Me source-conversation coordinate");
+  const sourceExternalId = text(source.sourceExternalId, "Message Like Me source-conversation coordinate.sourceExternalId");
+  const coordinate = plainObject(source.coordinate, "Message Like Me source-conversation coordinate.coordinate");
+  if (coordinate.kind === "beeperConversation") {
+    exactKeys(coordinate, ["kind", "network", "conversationId"], "Message Like Me Beeper coordinate");
+    const sourceAccountId = text(source.sourceAccountId, "Message Like Me source-conversation coordinate.sourceAccountId");
+    if (sourceExternalId !== sourceAccountId) {
+      return fail("Message Like Me Beeper source account and external identity must match");
+    }
+    return Object.freeze({
+      sourceAccountId,
+      sourceExternalId,
+      coordinate: Object.freeze({
+        kind: "beeperConversation",
+        network: text(coordinate.network, "Message Like Me Beeper coordinate.network", 512),
+        conversationId: text(coordinate.conversationId, "Message Like Me Beeper coordinate.conversationId")
+      })
+    });
+  }
+  if (coordinate.kind === "imessageChat") {
+    exactKeys(coordinate, ["kind", "chatGuid", "service", "observedChatRowId"], "Message Like Me iMessage coordinate");
+    if (source.sourceAccountId !== null) {
+      return fail("Message Like Me iMessage sourceAccountId must be null");
+    }
+    let observedChatRowId;
+    if (coordinate.observedChatRowId === null) {
+      observedChatRowId = null;
+    } else if (typeof coordinate.observedChatRowId === "number" && Number.isFinite(coordinate.observedChatRowId) && Number.isSafeInteger(coordinate.observedChatRowId) && coordinate.observedChatRowId >= 1) {
+      observedChatRowId = coordinate.observedChatRowId;
+    } else {
+      return fail("Message Like Me iMessage observedChatRowId must be a positive safe integer or null");
+    }
+    return Object.freeze({
+      sourceAccountId: null,
+      sourceExternalId,
+      coordinate: Object.freeze({
+        kind: "imessageChat",
+        chatGuid: text(coordinate.chatGuid, "Message Like Me iMessage coordinate.chatGuid"),
+        service: coordinate.service === null ? null : text(coordinate.service, "Message Like Me iMessage coordinate.service", 512),
+        observedChatRowId
+      })
+    });
+  }
+  return fail("Message Like Me source-conversation coordinate has an unsupported tag");
+}
+function messageLikeMeSourceConversationCoordinateBindingV1(value) {
+  const coordinate = parseMessageLikeMeSourceConversationCoordinateV1(value);
+  const canonicalPreimage = Object.freeze({
+    contractId: MESSAGE_LIKE_ME_SOURCE_CONVERSATION_COORDINATE_V1_CONTRACT_ID,
+    schemaVersion: MESSAGE_LIKE_ME_SOURCE_CONVERSATION_COORDINATE_V1_SCHEMA_VERSION,
+    value: coordinate
+  });
+  return Object.freeze({
+    contractId: MESSAGE_LIKE_ME_SOURCE_CONVERSATION_COORDINATE_V1_CONTRACT_ID,
+    schemaVersion: MESSAGE_LIKE_ME_SOURCE_CONVERSATION_COORDINATE_V1_SCHEMA_VERSION,
+    sha256: sha256(canonicalJson(canonicalPreimage))
+  });
+}
+function parseMessageLikeMeSourceConversationCoordinateBindingV1(value) {
+  const binding = plainObject(value, "Ghostget source-conversation coordinate binding");
+  exactKeys(binding, ["contractId", "schemaVersion", "sha256"], "Ghostget source-conversation coordinate binding");
+  if (binding.contractId !== MESSAGE_LIKE_ME_SOURCE_CONVERSATION_COORDINATE_V1_CONTRACT_ID || binding.schemaVersion !== MESSAGE_LIKE_ME_SOURCE_CONVERSATION_COORDINATE_V1_SCHEMA_VERSION)
+    return fail("Ghostget source-conversation coordinate binding has an unsupported contract identity");
+  return Object.freeze({
+    contractId: MESSAGE_LIKE_ME_SOURCE_CONVERSATION_COORDINATE_V1_CONTRACT_ID,
+    schemaVersion: MESSAGE_LIKE_ME_SOURCE_CONVERSATION_COORDINATE_V1_SCHEMA_VERSION,
+    sha256: digest(binding.sha256, "Ghostget source-conversation coordinate binding.sha256")
+  });
+}
+function parseGhostgetMessagingContextBindingV1(value) {
+  const context = plainObject(value, "Ghostget messaging context binding V1");
+  exactKeys(context, [
+    "schemaVersion",
+    "format",
+    "contractId",
+    "contractHash",
+    "routeRef",
+    "contextRef",
+    "exactDataRevision",
+    "latestMessageRevision",
+    "validatedAt",
+    "expiresAt"
+  ], "Ghostget messaging context binding V1");
+  if (context.schemaVersion !== 1 || context.format !== GHOSTGET_MESSAGING_CONTEXT_BINDING_V1_FORMAT || context.contractId !== GHOSTGET_MESSAGING_CONTEXT_BINDING_V1_CONTRACT_ID || context.contractHash !== GHOSTGET_MESSAGING_CONTEXT_BINDING_V1_CONTRACT_HASH)
+    return fail("Ghostget messaging context binding V1 has an unsupported contract identity");
+  const validatedAt = legacyTimestamp(context.validatedAt, "Ghostget messaging context binding V1.validatedAt");
+  const expiresAt = legacyTimestamp(context.expiresAt, "Ghostget messaging context binding V1.expiresAt");
+  if (Date.parse(expiresAt) <= Date.parse(validatedAt)) {
+    return fail("Ghostget messaging context binding V1.expiresAt must follow validatedAt");
+  }
+  return Object.freeze({
+    schemaVersion: 1,
+    format: GHOSTGET_MESSAGING_CONTEXT_BINDING_V1_FORMAT,
+    contractId: GHOSTGET_MESSAGING_CONTEXT_BINDING_V1_CONTRACT_ID,
+    contractHash: GHOSTGET_MESSAGING_CONTEXT_BINDING_V1_CONTRACT_HASH,
+    routeRef: text(context.routeRef, "Ghostget messaging context binding V1.routeRef", 2048),
+    contextRef: text(context.contextRef, "Ghostget messaging context binding V1.contextRef", 2048),
+    exactDataRevision: digest(context.exactDataRevision, "Ghostget messaging context binding V1.exactDataRevision"),
+    latestMessageRevision: digest(context.latestMessageRevision, "Ghostget messaging context binding V1.latestMessageRevision"),
+    validatedAt,
+    expiresAt
+  });
+}
+function parseGhostgetMessagingContextBindingV2(value) {
+  const context = plainObject(value, "Ghostget messaging context binding");
+  exactKeys(context, [
+    "schemaVersion",
+    "format",
+    "contractId",
+    "contractHash",
+    "sourceConversationCoordinate",
+    "routeRef",
+    "contextRef",
+    "exactDataRevision",
+    "latestMessageRevision",
+    "validatedAt",
+    "expiresAt"
+  ], "Ghostget messaging context binding");
+  if (context.schemaVersion !== 2 || context.format !== GHOSTGET_MESSAGING_CONTEXT_BINDING_V2_FORMAT || context.contractId !== GHOSTGET_MESSAGING_CONTEXT_BINDING_V2_CONTRACT_ID || context.contractHash !== GHOSTGET_MESSAGING_CONTEXT_BINDING_V2_CONTRACT_HASH)
+    return fail("Ghostget messaging context binding has an unsupported contract identity");
+  const validatedAt = timestamp(context.validatedAt, "Ghostget messaging context binding.validatedAt");
+  const expiresAt = timestamp(context.expiresAt, "Ghostget messaging context binding.expiresAt");
+  const lifetime = Date.parse(expiresAt) - Date.parse(validatedAt);
+  if (lifetime <= 0 || lifetime > 24 * 60 * 60 * 1000) {
+    return fail("Ghostget messaging context binding has an invalid lifetime");
+  }
+  return Object.freeze({
+    schemaVersion: 2,
+    format: GHOSTGET_MESSAGING_CONTEXT_BINDING_V2_FORMAT,
+    contractId: GHOSTGET_MESSAGING_CONTEXT_BINDING_V2_CONTRACT_ID,
+    contractHash: GHOSTGET_MESSAGING_CONTEXT_BINDING_V2_CONTRACT_HASH,
+    sourceConversationCoordinate: parseMessageLikeMeSourceConversationCoordinateBindingV1(context.sourceConversationCoordinate),
+    routeRef: text(context.routeRef, "Ghostget messaging context binding.routeRef", 2048),
+    contextRef: text(context.contextRef, "Ghostget messaging context binding.contextRef", 2048),
+    exactDataRevision: digest(context.exactDataRevision, "Ghostget messaging context binding.exactDataRevision"),
+    latestMessageRevision: digest(context.latestMessageRevision, "Ghostget messaging context binding.latestMessageRevision"),
+    validatedAt,
+    expiresAt
+  });
+}
+function ghostgetMessagingContextBindingSha256V1(value) {
+  const context = parseGhostgetMessagingContextBindingV1(value);
+  return sha256(canonicalJson({
+    contractId: GHOSTGET_MESSAGING_CONTEXT_INSTANCE_V1_CONTRACT_ID,
+    schemaVersion: 1,
+    value: context
+  }));
+}
+function parsedContextBindingSha256V2(context) {
+  return sha256(canonicalJson({
+    contractId: GHOSTGET_MESSAGING_CONTEXT_INSTANCE_V2_CONTRACT_ID,
+    schemaVersion: 2,
+    value: context
+  }));
+}
+function ghostgetMessagingContextBindingSha256V2(value) {
+  return parsedContextBindingSha256V2(parseGhostgetMessagingContextBindingV2(value));
+}
+var BEEPER_EXACT_CONVERSATION_KEYS = Object.freeze([
+  "id",
+  "localChatId",
+  "accountId",
+  "network",
+  "title",
+  "type",
+  "description",
+  "descriptionObserved",
+  "hasAvatar",
+  "avatarObserved",
+  "lastReadMessageSortKey",
+  "lastActivity",
+  "unreadCount",
+  "unreadMentionsCount",
+  "isMarkedUnread",
+  "isArchived",
+  "isLowPriority",
+  "isMuted",
+  "isPinned",
+  "isReadOnly",
+  "messageExpirySeconds",
+  "messageExpiryObserved",
+  "draft",
+  "draftObserved",
+  "reminder",
+  "reminderObserved",
+  "participants"
+]);
+function createBeeperMessageLikeMeSourceConversationCoordinateBindingV1(input) {
+  const read = plainObject(input.conversationRead, "Ghostget Beeper exact conversation read");
+  exactKeys(read, ["provider", "operation", "accountSubject", "conversation"], "Ghostget Beeper exact conversation read");
+  if (read.provider !== "beeper" || read.operation !== "conversations.read") {
+    return fail("Ghostget context requires an exact Beeper conversations.read projection");
+  }
+  const expectedAccountSubject = text(input.expectedAccountSubject, "Ghostget Beeper expected account subject");
+  if (text(read.accountSubject, "Ghostget Beeper exact conversation read.accountSubject") !== expectedAccountSubject)
+    return fail("Ghostget Beeper exact conversation read did not bind the expected account subject");
+  const conversation = plainObject(read.conversation, "Ghostget Beeper exact conversation read.conversation");
+  exactKeys(conversation, BEEPER_EXACT_CONVERSATION_KEYS, "Ghostget Beeper exact conversation read.conversation");
+  if (conversation.type !== "single") {
+    return fail("Ghostget Message Like Me context requires a direct Beeper conversation");
+  }
+  if (conversation.isReadOnly !== false) {
+    return fail("Ghostget Message Like Me context requires a writable Beeper conversation");
+  }
+  const accountId = text(conversation.accountId, "Ghostget Beeper exact conversation read.conversation.accountId");
+  return messageLikeMeSourceConversationCoordinateBindingV1({
+    sourceAccountId: accountId,
+    sourceExternalId: accountId,
+    coordinate: {
+      kind: "beeperConversation",
+      network: text(conversation.network, "Ghostget Beeper exact conversation read.conversation.network", 512),
+      conversationId: text(conversation.id, "Ghostget Beeper exact conversation read.conversation.id")
+    }
+  });
+}
+function createBeeperMessageLikeMeContextBindingV1(input) {
+  createBeeperMessageLikeMeSourceConversationCoordinateBindingV1({
+    conversationRead: input.conversationRead,
+    expectedAccountSubject: input.expectedAccountSubject
+  });
+  return parseGhostgetMessagingContextBindingV1(Object.freeze({
+    schemaVersion: 1,
+    format: GHOSTGET_MESSAGING_CONTEXT_BINDING_V1_FORMAT,
+    contractId: GHOSTGET_MESSAGING_CONTEXT_BINDING_V1_CONTRACT_ID,
+    contractHash: GHOSTGET_MESSAGING_CONTEXT_BINDING_V1_CONTRACT_HASH,
+    routeRef: text(input.routeRef, "Ghostget messaging context binding V1.routeRef", 2048),
+    contextRef: text(input.contextRef, "Ghostget messaging context binding V1.contextRef", 2048),
+    exactDataRevision: digest(input.exactDataRevision, "Ghostget messaging context binding V1.exactDataRevision"),
+    latestMessageRevision: digest(input.latestMessageRevision, "Ghostget messaging context binding V1.latestMessageRevision"),
+    validatedAt: input.validatedAt,
+    expiresAt: input.expiresAt
+  }));
+}
+function createBeeperMessageLikeMeContextBindingV2(input) {
+  const sourceConversationCoordinate = createBeeperMessageLikeMeSourceConversationCoordinateBindingV1({
+    conversationRead: input.conversationRead,
+    expectedAccountSubject: input.expectedAccountSubject
+  });
+  return parseGhostgetMessagingContextBindingV2(Object.freeze({
+    schemaVersion: 2,
+    format: GHOSTGET_MESSAGING_CONTEXT_BINDING_V2_FORMAT,
+    contractId: GHOSTGET_MESSAGING_CONTEXT_BINDING_V2_CONTRACT_ID,
+    contractHash: GHOSTGET_MESSAGING_CONTEXT_BINDING_V2_CONTRACT_HASH,
+    sourceConversationCoordinate,
+    routeRef: text(input.routeRef, "Ghostget messaging context binding.routeRef", 2048),
+    contextRef: text(input.contextRef, "Ghostget messaging context binding.contextRef", 2048),
+    exactDataRevision: digest(input.exactDataRevision, "Ghostget messaging context binding.exactDataRevision"),
+    latestMessageRevision: digest(input.latestMessageRevision, "Ghostget messaging context binding.latestMessageRevision"),
+    validatedAt: input.validatedAt,
+    expiresAt: input.expiresAt
+  }));
+}
+function parseGhostgetMessagingClientIntentBindingV1(value, contextValue) {
+  const context = parseGhostgetMessagingContextBindingV2(contextValue);
+  const intent = plainObject(value, "Ghostget messaging client-intent binding");
+  exactKeys(intent, [
+    "schemaVersion",
+    "format",
+    "contractId",
+    "clientIntentSha256",
+    "contextBindingSha256",
+    "sourceConversationCoordinateSha256",
+    "routeRefSha256",
+    "contextRefSha256",
+    "turnDigest",
+    "partCount"
+  ], "Ghostget messaging client-intent binding");
+  if (intent.schemaVersion !== 1 || intent.format !== GHOSTGET_MESSAGING_CLIENT_INTENT_BINDING_V1_FORMAT || intent.contractId !== GHOSTGET_MESSAGING_CLIENT_INTENT_BINDING_V1_CONTRACT_ID)
+    return fail("Ghostget messaging client-intent binding has an unsupported contract identity");
+  if (!Number.isSafeInteger(intent.partCount) || intent.partCount < 1 || intent.partCount > 8) {
+    return fail("Ghostget messaging client-intent binding.partCount must be from 1 through 8");
+  }
+  const parsed = Object.freeze({
+    schemaVersion: 1,
+    format: GHOSTGET_MESSAGING_CLIENT_INTENT_BINDING_V1_FORMAT,
+    contractId: GHOSTGET_MESSAGING_CLIENT_INTENT_BINDING_V1_CONTRACT_ID,
+    clientIntentSha256: digest(intent.clientIntentSha256, "Ghostget messaging client-intent binding.clientIntentSha256"),
+    contextBindingSha256: digest(intent.contextBindingSha256, "Ghostget messaging client-intent binding.contextBindingSha256"),
+    sourceConversationCoordinateSha256: digest(intent.sourceConversationCoordinateSha256, "Ghostget messaging client-intent binding.sourceConversationCoordinateSha256"),
+    routeRefSha256: digest(intent.routeRefSha256, "Ghostget messaging client-intent binding.routeRefSha256"),
+    contextRefSha256: digest(intent.contextRefSha256, "Ghostget messaging client-intent binding.contextRefSha256"),
+    turnDigest: digest(intent.turnDigest, "Ghostget messaging client-intent binding.turnDigest"),
+    partCount: intent.partCount
+  });
+  if (parsed.contextBindingSha256 !== parsedContextBindingSha256V2(context) || parsed.sourceConversationCoordinateSha256 !== context.sourceConversationCoordinate.sha256 || parsed.routeRefSha256 !== sha256(context.routeRef) || parsed.contextRefSha256 !== sha256(context.contextRef))
+    return fail("Ghostget messaging client intent does not bind the exact context instance");
+  return parsed;
+}
+function createGhostgetMessagingReceiptBindingV2(input) {
+  const intent = parseGhostgetMessagingClientIntentBindingV1(input.clientIntent, input.context);
+  if (input.state !== "submitted" && input.state !== "failed" && input.state !== "partial" && input.state !== "indeterminate")
+    return fail("Ghostget messaging receipt binding has an invalid state");
+  if (!Number.isSafeInteger(input.provenPartCount) || input.provenPartCount < 0 || input.provenPartCount > intent.partCount)
+    return fail("Ghostget messaging receipt binding.provenPartCount is out of range");
+  const provenPartCount = input.provenPartCount;
+  if (input.state === "submitted" && provenPartCount !== intent.partCount || input.state === "failed" && provenPartCount !== 0 || input.state === "partial" && (provenPartCount < 1 || provenPartCount >= intent.partCount) || input.state === "indeterminate" && provenPartCount >= intent.partCount)
+    return fail("Ghostget messaging receipt binding state does not match its proven prefix");
+  const core = Object.freeze({
+    schemaVersion: 2,
+    format: GHOSTGET_MESSAGING_RECEIPT_BINDING_V2_FORMAT,
+    contractId: GHOSTGET_MESSAGING_RECEIPT_BINDING_V2_CONTRACT_ID,
+    contractHash: GHOSTGET_MESSAGING_RECEIPT_BINDING_V2_CONTRACT_HASH,
+    clientIntentSha256: intent.clientIntentSha256,
+    contextBindingSha256: intent.contextBindingSha256,
+    sourceConversationCoordinateSha256: intent.sourceConversationCoordinateSha256,
+    routeRefSha256: intent.routeRefSha256,
+    contextRefSha256: intent.contextRefSha256,
+    turnDigest: intent.turnDigest,
+    previewDigest: digest(input.previewDigest, "Ghostget receipt.previewDigest"),
+    runId: text(input.runId, "Ghostget receipt.runId", 256),
+    state: input.state,
+    partCount: intent.partCount,
+    provenPartCount,
+    recordedAt: timestamp(input.recordedAt, "Ghostget receipt.recordedAt")
+  });
+  return Object.freeze({
+    ...core,
+    receiptSha256: sha256(canonicalJson(core))
+  });
+}
+function createGhostgetMessagingReceiptBindingV1(input) {
+  const enriched = createGhostgetMessagingReceiptBindingV2(input);
+  const core = Object.freeze({
+    schemaVersion: 1,
+    format: GHOSTGET_MESSAGING_RECEIPT_BINDING_V1_FORMAT,
+    contractId: GHOSTGET_MESSAGING_RECEIPT_BINDING_V1_CONTRACT_ID,
+    contractHash: GHOSTGET_MESSAGING_RECEIPT_BINDING_V1_CONTRACT_HASH,
+    clientIntentSha256: enriched.clientIntentSha256,
+    routeRefSha256: enriched.routeRefSha256,
+    contextRefSha256: enriched.contextRefSha256,
+    turnDigest: enriched.turnDigest,
+    previewDigest: enriched.previewDigest,
+    runId: enriched.runId,
+    state: enriched.state,
+    partCount: enriched.partCount,
+    provenPartCount: enriched.provenPartCount,
+    recordedAt: enriched.recordedAt
+  });
+  return Object.freeze({
+    ...core,
+    receiptSha256: sha256(canonicalJson(core))
+  });
+}
+
+export { MESSAGE_LIKE_ME_SOURCE_CONVERSATION_COORDINATE_V1_SCHEMA_VERSION, MESSAGE_LIKE_ME_SOURCE_CONVERSATION_COORDINATE_V1_CONTRACT_ID, GHOSTGET_MESSAGING_CONTEXT_BINDING_V1_FORMAT, GHOSTGET_MESSAGING_CONTEXT_BINDING_V1_CONTRACT_ID, GHOSTGET_MESSAGING_CONTEXT_BINDING_V1_CONTRACT_DESCRIPTOR, GHOSTGET_MESSAGING_CONTEXT_BINDING_V1_CONTRACT_HASH, GHOSTGET_MESSAGING_RECEIPT_BINDING_V1_FORMAT, GHOSTGET_MESSAGING_RECEIPT_BINDING_V1_CONTRACT_ID, GHOSTGET_MESSAGING_RECEIPT_BINDING_V1_CONTRACT_DESCRIPTOR, GHOSTGET_MESSAGING_RECEIPT_BINDING_V1_CONTRACT_HASH, GHOSTGET_MESSAGING_CONTEXT_BINDING_V2_FORMAT, GHOSTGET_MESSAGING_CONTEXT_BINDING_V2_CONTRACT_ID, GHOSTGET_MESSAGING_CONTEXT_BINDING_V2_CONTRACT_DESCRIPTOR, GHOSTGET_MESSAGING_CONTEXT_BINDING_V2_CONTRACT_HASH, GHOSTGET_MESSAGING_RECEIPT_BINDING_V2_FORMAT, GHOSTGET_MESSAGING_RECEIPT_BINDING_V2_CONTRACT_ID, GHOSTGET_MESSAGING_RECEIPT_BINDING_V2_CONTRACT_DESCRIPTOR, GHOSTGET_MESSAGING_RECEIPT_BINDING_V2_CONTRACT_HASH, GHOSTGET_MESSAGING_CLIENT_INTENT_BINDING_V1_FORMAT, GHOSTGET_MESSAGING_CLIENT_INTENT_BINDING_V1_CONTRACT_ID, GHOSTGET_MESSAGING_CONTEXT_INSTANCE_V1_CONTRACT_ID, GHOSTGET_MESSAGING_CONTEXT_INSTANCE_V2_CONTRACT_ID, parseMessageLikeMeSourceConversationCoordinateV1, messageLikeMeSourceConversationCoordinateBindingV1, parseGhostgetMessagingContextBindingV1, parseGhostgetMessagingContextBindingV2, ghostgetMessagingContextBindingSha256V1, ghostgetMessagingContextBindingSha256V2, createBeeperMessageLikeMeContextBindingV1, createBeeperMessageLikeMeContextBindingV2, parseGhostgetMessagingClientIntentBindingV1, createGhostgetMessagingReceiptBindingV2, createGhostgetMessagingReceiptBindingV1 };

package/dist/index-axwm9b3v.js

@@ -0,0 +1,5 @@
+// @bun
+// src/version.ts
+var GHOSTGET_VERSION = "0.17.2";
+
+export { GHOSTGET_VERSION };

package/dist/index-gwk7rbyj.js

@@ -0,0 +1,30 @@
+// @bun
+// src/canonical-json.ts
+import { createHash } from "crypto";
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function canonicalJson(value) {
+  if (value === null || typeof value === "boolean" || typeof value === "string") {
+    return JSON.stringify(value);
+  }
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) {
+      throw new Error("canonical JSON cannot represent a non-finite number");
+    }
+    return JSON.stringify(value);
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map((item) => canonicalJson(item)).join(",")}]`;
+  }
+  if (isRecord(value)) {
+    const entries = Object.entries(value).filter(([, item]) => item !== undefined).sort(([left], [right]) => left.localeCompare(right));
+    return `{${entries.map(([key, item]) => `${JSON.stringify(key)}:${canonicalJson(item)}`).join(",")}}`;
+  }
+  throw new Error("canonical JSON supports only JSON-compatible values");
+}
+function sha256(value) {
+  return createHash("sha256").update(value).digest("hex");
+}
+
+export { canonicalJson, sha256 };