@opengeni/contracts 0.44.1 → 1.0.0

package/dist/chunk-KHHZTBP7.js

@@ -0,0 +1,11 @@
+// src/session-final-reply.ts
+var EMPTY_FINAL_REPLY_NOTICE = "The model returned no final reply after a reply reminder. Completed work is preserved; the goal and later updates are unaffected.";
+function turnCompletedWithEmptyFinalReply(payload) {
+  return payload !== null && typeof payload === "object" && !Array.isArray(payload) && payload.emptyFinalReply === true;
+}
+
+export {
+  EMPTY_FINAL_REPLY_NOTICE,
+  turnCompletedWithEmptyFinalReply
+};
+//# sourceMappingURL=chunk-KHHZTBP7.js.map

package/dist/chunk-KHHZTBP7.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/session-final-reply.ts"],"sourcesContent":["/** A response-quality notice, not a failed turn or a completed deliverable. */\nexport const EMPTY_FINAL_REPLY_NOTICE =\n  \"The model returned no final reply after a reply reminder. Completed work is preserved; the goal and later updates are unaffected.\";\n\nexport type EmptyFinalReplyCompletion = {\n  emptyFinalReply: true;\n};\n\nexport function turnCompletedWithEmptyFinalReply(payload: unknown): boolean {\n  return (\n    payload !== null &&\n    typeof payload === \"object\" &&\n    !Array.isArray(payload) &&\n    (payload as { emptyFinalReply?: unknown }).emptyFinalReply === true\n  );\n}\n"],"mappings":";AACO,IAAM,2BACX;AAMK,SAAS,iCAAiC,SAA2B;AAC1E,SACE,YAAY,QACZ,OAAO,YAAY,YACnB,CAAC,MAAM,QAAQ,OAAO,KACrB,QAA0C,oBAAoB;AAEnE;","names":[]}

package/dist/chunk-KR2V42UZ.js

@@ -0,0 +1,187 @@
+import {
+  Permission
+} from "./chunk-QR5D2IQC.js";
+
+// src/external-identities.ts
+import { z } from "zod";
+var encoder = new TextEncoder();
+function opaqueText(maxBytes) {
+  return z.string().min(1).max(maxBytes).refine(
+    (value) => !value.includes("\0") && !/[\uD800-\uDFFF]/u.test(value) && encoder.encode(value).byteLength <= maxBytes,
+    {
+      message: `Identifier must be valid PostgreSQL Unicode text of at most ${maxBytes} UTF-8 bytes`
+    }
+  );
+}
+var externalId = opaqueText(1024);
+var source = opaqueText(200);
+var externalSubject = z.string().regex(/^external_user:[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$(?![\s\S])/);
+var nativeSubject = z.string().min(1).max(1024).regex(/^user:[^\r\n]+$(?![\s\S])/);
+var ExternalIdentityReference = z.object({
+  externalId,
+  source: source.default("default")
+}).strict();
+var AddExternalWorkspaceMemberRequest = z.object({
+  identity: ExternalIdentityReference,
+  permissions: z.array(Permission).min(1).max(Permission.options.length),
+  /** Opt-in durable operation identity; unkeyed legacy requests are not cancellable. */
+  operationId: z.string().uuid().optional()
+}).strict();
+var ExternalIdentityLookup = z.discriminatedUnion("found", [
+  z.object({ found: z.literal(false) }).strict(),
+  z.object({
+    found: z.literal(true),
+    subjectId: externalSubject,
+    organizationMembershipId: z.string().uuid(),
+    identityStatus: z.enum(["active", "disabled", "revoked"]),
+    identityAuthorizationRevision: z.number().int().positive().safe(),
+    membershipStatus: z.enum(["provisioning", "active", "suspended", "revoked"]),
+    membershipAuthorizationRevision: z.number().int().positive().safe()
+  }).strict()
+]);
+var CancelExternalWorkspaceMemberGrantRequest = z.object({
+  operationId: z.string().uuid(),
+  cancelGrantOperationId: z.string().uuid()
+}).strict().refine((value) => value.operationId !== value.cancelGrantOperationId, {
+  message: "Revocation and grant must use different operation identities"
+});
+var CancelExternalWorkspaceMemberGrantResponse = z.object({
+  removed: z.boolean(),
+  replay: z.boolean(),
+  fencedGrantOperationId: z.string().uuid()
+}).strict();
+var UpdateExternalWorkspaceMemberRequest = z.object({
+  permissions: z.array(Permission).min(1).max(Permission.options.length),
+  operationId: z.string().uuid()
+}).strict();
+var UpdateExternalWorkspaceMemberResponse = z.object({
+  subjectId: z.string(),
+  organizationMembershipId: z.string().uuid(),
+  permissions: z.array(Permission),
+  /** True when a previously held permission was removed. */
+  narrowed: z.boolean(),
+  replay: z.boolean()
+}).strict();
+var UpdateExternalIdentityMembershipRequest = z.object({
+  kind: z.enum(["suspend", "reactivate", "offboard"]),
+  expectedAuthorizationRevision: z.number().int().positive().safe(),
+  operationId: z.string().uuid(),
+  reason: z.string().max(512).optional()
+}).strict();
+var ExternalActorSelection = z.discriminatedUnion("mode", [
+  z.object({ mode: z.literal("external"), identity: ExternalIdentityReference }).strict(),
+  z.object({
+    mode: z.literal("linked_native"),
+    identity: ExternalIdentityReference,
+    linkId: z.string().uuid(),
+    expectedLinkRevision: z.number().int().positive().safe()
+  }).strict()
+]);
+var ExternalIdentity = z.object({
+  id: z.string().uuid(),
+  accountId: z.string().uuid(),
+  source,
+  externalId,
+  subjectId: externalSubject,
+  organizationMembershipId: z.string().uuid(),
+  personalWorkspaceId: z.string().uuid(),
+  status: z.enum(["active", "disabled", "revoked"]),
+  authorizationRevision: z.number().int().positive().safe()
+}).strict();
+var ExternalActorAttribution = z.object({
+  accountId: z.string().uuid(),
+  authenticatingApiKeyId: z.string().uuid(),
+  externalIdentityId: z.string().uuid(),
+  externalSubjectId: externalSubject,
+  externalAuthorizationRevision: z.number().int().positive().safe(),
+  effectiveSubjectId: z.string().min(1).max(1024),
+  actingMode: z.enum(["external", "linked_native"]),
+  linkId: z.string().uuid().optional(),
+  linkRevision: z.number().int().positive().safe().optional()
+}).strict().superRefine((value, context) => {
+  if (value.actingMode === "external") {
+    if (value.effectiveSubjectId !== value.externalSubjectId || value.linkId !== void 0 || value.linkRevision !== void 0) {
+      context.addIssue({
+        code: "custom",
+        message: "External mode cannot delegate native identity"
+      });
+    }
+  } else if (!value.linkId || !value.linkRevision || !nativeSubject.safeParse(value.effectiveSubjectId).success) {
+    context.addIssue({
+      code: "custom",
+      message: "Linked mode requires exact native delegation provenance"
+    });
+  }
+});
+var ExternalActorContinuation = z.object({
+  identity: ExternalIdentityReference,
+  actor: ExternalActorAttribution
+}).strict();
+var ExternalIdentityLink = z.object({
+  id: z.string().uuid(),
+  accountId: z.string().uuid(),
+  externalIdentityId: z.string().uuid(),
+  externalIdentity: ExternalIdentityReference.optional(),
+  nativeSubjectId: nativeSubject.nullable(),
+  status: z.enum(["pending", "active", "revoked", "expired"]),
+  revision: z.number().int().positive().safe(),
+  permissions: z.array(Permission).max(Permission.options.length),
+  expiresAt: z.string().datetime({ offset: true }).nullable()
+}).strict().refine(
+  (value) => value.status !== "active" || value.nativeSubjectId !== null,
+  "An active link requires a confirmed native identity"
+);
+var ExternalIdentityLinkPage = z.object({
+  links: z.array(ExternalIdentityLink).max(50),
+  nextCursor: z.string().uuid().nullable()
+}).strict();
+var BeginExternalIdentityLinkRequest = z.object({
+  permissions: z.array(Permission).min(1).max(Permission.options.length),
+  expiresAt: z.string().datetime({ offset: true }).nullable().default(null)
+}).strict();
+var ConfirmExternalIdentityLinkRequest = z.object({
+  challenge: z.string().regex(/^[A-Za-z0-9_-]{43}$/),
+  expectedRevision: z.number().int().positive().safe(),
+  permissions: z.array(Permission).min(1).max(Permission.options.length)
+}).strict();
+var BeginExternalIdentityLinkResponse = z.object({
+  link: ExternalIdentityLink,
+  challenge: z.string().regex(/^[A-Za-z0-9_-]{43}$/),
+  confirmBefore: z.string().datetime({ offset: true })
+}).strict();
+var ExternalIdentityLinkPreview = z.object({
+  link: ExternalIdentityLink,
+  externalIdentity: ExternalIdentityReference,
+  nativeSubjectId: nativeSubject,
+  organizationId: z.string().uuid()
+}).strict();
+var ExternalLinkWorkSnapshot = z.object({
+  identity: ExternalIdentityReference,
+  actor: ExternalActorAttribution.refine((value) => value.actingMode === "linked_native"),
+  permissions: z.array(Permission).max(Permission.options.length),
+  /** Absent on historical snapshots, whose legacy semantics are preserved. */
+  permissionMode: z.enum(["legacy", "explicit"]).optional()
+}).strict();
+
+export {
+  ExternalIdentityReference,
+  AddExternalWorkspaceMemberRequest,
+  ExternalIdentityLookup,
+  CancelExternalWorkspaceMemberGrantRequest,
+  CancelExternalWorkspaceMemberGrantResponse,
+  UpdateExternalWorkspaceMemberRequest,
+  UpdateExternalWorkspaceMemberResponse,
+  UpdateExternalIdentityMembershipRequest,
+  ExternalActorSelection,
+  ExternalIdentity,
+  ExternalActorAttribution,
+  ExternalActorContinuation,
+  ExternalIdentityLink,
+  ExternalIdentityLinkPage,
+  BeginExternalIdentityLinkRequest,
+  ConfirmExternalIdentityLinkRequest,
+  BeginExternalIdentityLinkResponse,
+  ExternalIdentityLinkPreview,
+  ExternalLinkWorkSnapshot
+};
+//# sourceMappingURL=chunk-KR2V42UZ.js.map

package/dist/chunk-KR2V42UZ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/external-identities.ts"],"sourcesContent":["import { z } from \"zod\";\nimport { Permission } from \"./permissions\";\n\n// External identifiers are opaque, case-sensitive strings. In particular a\n// native-looking identifier is still host data, never a native subject claim.\n// Bound bytes, not just JS code units: these values share a PostgreSQL B-tree\n// index entry. Never normalize/truncate an identifier to make it fit, and reject\n// text that the driver would replace or PostgreSQL cannot represent.\nconst encoder = new TextEncoder();\nfunction opaqueText(maxBytes: number) {\n  return z\n    .string()\n    .min(1)\n    .max(maxBytes)\n    .refine(\n      (value) =>\n        !value.includes(\"\\0\") &&\n        !/[\\uD800-\\uDFFF]/u.test(value) &&\n        encoder.encode(value).byteLength <= maxBytes,\n      {\n        message: `Identifier must be valid PostgreSQL Unicode text of at most ${maxBytes} UTF-8 bytes`,\n      },\n    );\n}\nconst externalId = opaqueText(1024);\nconst source = opaqueText(200);\nconst externalSubject = z\n  .string()\n  .regex(/^external_user:[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$(?![\\s\\S])/);\nconst nativeSubject = z\n  .string()\n  .min(1)\n  .max(1024)\n  .regex(/^user:[^\\r\\n]+$(?![\\s\\S])/);\nexport const ExternalIdentityReference = z\n  .object({\n    externalId,\n    source: source.default(\"default\"),\n  })\n  .strict();\nexport type ExternalIdentityReference = z.infer<typeof ExternalIdentityReference>;\n\nexport const AddExternalWorkspaceMemberRequest = z\n  .object({\n    identity: ExternalIdentityReference,\n    permissions: z.array(Permission).min(1).max(Permission.options.length),\n    /** Opt-in durable operation identity; unkeyed legacy requests are not cancellable. */\n    operationId: z.string().uuid().optional(),\n  })\n  .strict();\nexport type AddExternalWorkspaceMemberRequest = z.infer<typeof AddExternalWorkspaceMemberRequest>;\n\n/** Content-free service lookup, including identities which can no longer act. */\nexport const ExternalIdentityLookup = z.discriminatedUnion(\"found\", [\n  z.object({ found: z.literal(false) }).strict(),\n  z\n    .object({\n      found: z.literal(true),\n      subjectId: externalSubject,\n      organizationMembershipId: z.string().uuid(),\n      identityStatus: z.enum([\"active\", \"disabled\", \"revoked\"]),\n      identityAuthorizationRevision: z.number().int().positive().safe(),\n      membershipStatus: z.enum([\"provisioning\", \"active\", \"suspended\", \"revoked\"]),\n      membershipAuthorizationRevision: z.number().int().positive().safe(),\n    })\n    .strict(),\n]);\nexport type ExternalIdentityLookup = z.infer<typeof ExternalIdentityLookup>;\n\n/** Terminal withdrawal of this external member's workspace access, also fencing\n * an exact earlier onboarding operation whether or not it has reached the API. */\nexport const CancelExternalWorkspaceMemberGrantRequest = z\n  .object({\n    operationId: z.string().uuid(),\n    cancelGrantOperationId: z.string().uuid(),\n  })\n  .strict()\n  .refine((value) => value.operationId !== value.cancelGrantOperationId, {\n    message: \"Revocation and grant must use different operation identities\",\n  });\nexport type CancelExternalWorkspaceMemberGrantRequest = z.infer<\n  typeof CancelExternalWorkspaceMemberGrantRequest\n>;\nexport const CancelExternalWorkspaceMemberGrantResponse = z\n  .object({\n    removed: z.boolean(),\n    replay: z.boolean(),\n    fencedGrantOperationId: z.string().uuid(),\n  })\n  .strict();\nexport type CancelExternalWorkspaceMemberGrantResponse = z.infer<\n  typeof CancelExternalWorkspaceMemberGrantResponse\n>;\n\n/** Replace an existing external member's permissions in one shared workspace.\n * Keyed and idempotent like a grant; narrowing forces live authority to\n * re-check but never cancels or tears down work. */\nexport const UpdateExternalWorkspaceMemberRequest = z\n  .object({\n    permissions: z.array(Permission).min(1).max(Permission.options.length),\n    operationId: z.string().uuid(),\n  })\n  .strict();\nexport type UpdateExternalWorkspaceMemberRequest = z.infer<\n  typeof UpdateExternalWorkspaceMemberRequest\n>;\nexport const UpdateExternalWorkspaceMemberResponse = z\n  .object({\n    subjectId: z.string(),\n    organizationMembershipId: z.string().uuid(),\n    permissions: z.array(Permission),\n    /** True when a previously held permission was removed. */\n    narrowed: z.boolean(),\n    replay: z.boolean(),\n  })\n  .strict();\nexport type UpdateExternalWorkspaceMemberResponse = z.infer<\n  typeof UpdateExternalWorkspaceMemberResponse\n>;\n\n/** Uses the organization membership ID returned by lazy identity admission.\n * Reactivation restores admission only, not revoked work or workspace grants. */\nexport const UpdateExternalIdentityMembershipRequest = z\n  .object({\n    kind: z.enum([\"suspend\", \"reactivate\", \"offboard\"]),\n    expectedAuthorizationRevision: z.number().int().positive().safe(),\n    operationId: z.string().uuid(),\n    reason: z.string().max(512).optional(),\n  })\n  .strict();\nexport type UpdateExternalIdentityMembershipRequest = z.infer<\n  typeof UpdateExternalIdentityMembershipRequest\n>;\n\nexport const ExternalActorSelection = z.discriminatedUnion(\"mode\", [\n  z.object({ mode: z.literal(\"external\"), identity: ExternalIdentityReference }).strict(),\n  z\n    .object({\n      mode: z.literal(\"linked_native\"),\n      identity: ExternalIdentityReference,\n      linkId: z.string().uuid(),\n      expectedLinkRevision: z.number().int().positive().safe(),\n    })\n    .strict(),\n]);\nexport type ExternalActorSelection = z.infer<typeof ExternalActorSelection>;\n\nexport const ExternalIdentity = z\n  .object({\n    id: z.string().uuid(),\n    accountId: z.string().uuid(),\n    source,\n    externalId,\n    subjectId: externalSubject,\n    organizationMembershipId: z.string().uuid(),\n    personalWorkspaceId: z.string().uuid(),\n    status: z.enum([\"active\", \"disabled\", \"revoked\"]),\n    authorizationRevision: z.number().int().positive().safe(),\n  })\n  .strict();\nexport type ExternalIdentity = z.infer<typeof ExternalIdentity>;\n\n// Audit attribution, not authentication. Only the canonical access resolver\n// may establish provenance; accepting this JSON from a browser proves nothing.\nexport const ExternalActorAttribution = z\n  .object({\n    accountId: z.string().uuid(),\n    authenticatingApiKeyId: z.string().uuid(),\n    externalIdentityId: z.string().uuid(),\n    externalSubjectId: externalSubject,\n    externalAuthorizationRevision: z.number().int().positive().safe(),\n    effectiveSubjectId: z.string().min(1).max(1024),\n    actingMode: z.enum([\"external\", \"linked_native\"]),\n    linkId: z.string().uuid().optional(),\n    linkRevision: z.number().int().positive().safe().optional(),\n  })\n  .strict()\n  .superRefine((value, context) => {\n    if (value.actingMode === \"external\") {\n      if (\n        value.effectiveSubjectId !== value.externalSubjectId ||\n        value.linkId !== undefined ||\n        value.linkRevision !== undefined\n      ) {\n        context.addIssue({\n          code: \"custom\",\n          message: \"External mode cannot delegate native identity\",\n        });\n      }\n    } else if (\n      !value.linkId ||\n      !value.linkRevision ||\n      !nativeSubject.safeParse(value.effectiveSubjectId).success\n    ) {\n      context.addIssue({\n        code: \"custom\",\n        message: \"Linked mode requires exact native delegation provenance\",\n      });\n    }\n  });\nexport type ExternalActorAttribution = z.infer<typeof ExternalActorAttribution>;\n\n/** Server-signed/encrypted continuation data, never sufficient live authority. */\nexport const ExternalActorContinuation = z\n  .object({\n    identity: ExternalIdentityReference,\n    actor: ExternalActorAttribution,\n  })\n  .strict();\nexport type ExternalActorContinuation = z.infer<typeof ExternalActorContinuation>;\n\nexport const ExternalIdentityLink = z\n  .object({\n    id: z.string().uuid(),\n    accountId: z.string().uuid(),\n    externalIdentityId: z.string().uuid(),\n    externalIdentity: ExternalIdentityReference.optional(),\n    nativeSubjectId: nativeSubject.nullable(),\n    status: z.enum([\"pending\", \"active\", \"revoked\", \"expired\"]),\n    revision: z.number().int().positive().safe(),\n    permissions: z.array(Permission).max(Permission.options.length),\n    expiresAt: z.string().datetime({ offset: true }).nullable(),\n  })\n  .strict()\n  .refine(\n    (value) => value.status !== \"active\" || value.nativeSubjectId !== null,\n    \"An active link requires a confirmed native identity\",\n  );\nexport type ExternalIdentityLink = z.infer<typeof ExternalIdentityLink>;\n\nexport const ExternalIdentityLinkPage = z\n  .object({\n    links: z.array(ExternalIdentityLink).max(50),\n    nextCursor: z.string().uuid().nullable(),\n  })\n  .strict();\nexport type ExternalIdentityLinkPage = z.infer<typeof ExternalIdentityLinkPage>;\n\n/** A native confirmation may narrow this request, never broaden it. The\n * challenge is delivered once to the host and is not an authentication token. */\nexport const BeginExternalIdentityLinkRequest = z\n  .object({\n    permissions: z.array(Permission).min(1).max(Permission.options.length),\n    expiresAt: z.string().datetime({ offset: true }).nullable().default(null),\n  })\n  .strict();\nexport type BeginExternalIdentityLinkRequest = z.input<typeof BeginExternalIdentityLinkRequest>;\nexport const ConfirmExternalIdentityLinkRequest = z\n  .object({\n    challenge: z.string().regex(/^[A-Za-z0-9_-]{43}$/),\n    expectedRevision: z.number().int().positive().safe(),\n    permissions: z.array(Permission).min(1).max(Permission.options.length),\n  })\n  .strict();\nexport type ConfirmExternalIdentityLinkRequest = z.infer<typeof ConfirmExternalIdentityLinkRequest>;\nexport const BeginExternalIdentityLinkResponse = z\n  .object({\n    link: ExternalIdentityLink,\n    challenge: z.string().regex(/^[A-Za-z0-9_-]{43}$/),\n    confirmBefore: z.string().datetime({ offset: true }),\n  })\n  .strict();\nexport type BeginExternalIdentityLinkResponse = z.infer<typeof BeginExternalIdentityLinkResponse>;\nexport const ExternalIdentityLinkPreview = z\n  .object({\n    link: ExternalIdentityLink,\n    externalIdentity: ExternalIdentityReference,\n    nativeSubjectId: nativeSubject,\n    organizationId: z.string().uuid(),\n  })\n  .strict();\nexport type ExternalIdentityLinkPreview = z.infer<typeof ExternalIdentityLinkPreview>;\n\n/** Immutable accepted-work restriction, not a browser credential. Original key\n * identity remains audit-only; durable use validates the live link and members. */\nexport const ExternalLinkWorkSnapshot = z\n  .object({\n    identity: ExternalIdentityReference,\n    actor: ExternalActorAttribution.refine((value) => value.actingMode === \"linked_native\"),\n    permissions: z.array(Permission).max(Permission.options.length),\n    /** Absent on historical snapshots, whose legacy semantics are preserved. */\n    permissionMode: z.enum([\"legacy\", \"explicit\"]).optional(),\n  })\n  .strict();\nexport type ExternalLinkWorkSnapshot = z.infer<typeof ExternalLinkWorkSnapshot>;\n"],"mappings":"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","names":[]}

package/dist/chunk-MZLBPKFE.js

@@ -0,0 +1,168 @@
+// src/slack-rest-mcp.ts
+var OFFICIAL_SLACK_MCP_URL = "https://mcp.slack.com/mcp";
+var SLACK_REST_API_BASE = "https://slack.com/api/";
+var OPENGENI_SLACK_REST_USER_SCOPES = [
+  "channels:read",
+  "groups:read",
+  "im:read",
+  "mpim:read",
+  "channels:history",
+  "groups:history",
+  "im:history",
+  "mpim:history",
+  "users:read",
+  "im:write",
+  "chat:write"
+];
+function normalizeSlackScopes(scopes) {
+  return [
+    ...new Set(
+      (typeof scopes === "string" ? [scopes] : scopes ?? []).flatMap((entry) => entry.split(/[\s,]+/u)).filter(Boolean)
+    )
+  ].sort();
+}
+var conversationScopes = ["channels:read", "groups:read", "im:read", "mpim:read"];
+var historyScopes = ["channels:history", "groups:history", "im:history", "mpim:history"];
+var channel = { type: "string", description: "Slack conversation ID, such as C123 or D123." };
+var cursor = { type: "string", maxLength: 4096, description: "Cursor from the previous page." };
+var directoryPage = { type: "integer", minimum: 1, maximum: 100, default: 100 };
+var historyPage = { type: "integer", minimum: 1, maximum: 15, default: 15 };
+var timestamp = { type: "string", pattern: "^[0-9]+\\.[0-9]+$" };
+function tool(name, description, properties, required = [], mutation = false) {
+  return {
+    name,
+    description,
+    inputSchema: { type: "object", properties, required, additionalProperties: false },
+    annotations: {
+      readOnlyHint: !mutation,
+      destructiveHint: false,
+      idempotentHint: !mutation,
+      openWorldHint: true
+    }
+  };
+}
+var SLACK_REST_MCP_TOOLS = [
+  tool(
+    "slack_list_channels",
+    "Lists one page of conversations visible to your connected Slack account. Conversation types without a granted read scope are omitted.",
+    {
+      types: {
+        type: "array",
+        items: { type: "string", enum: ["public_channel", "private_channel", "im", "mpim"] },
+        minItems: 1,
+        maxItems: 4
+      },
+      cursor,
+      limit: directoryPage,
+      exclude_archived: { type: "boolean", default: true }
+    }
+  ),
+  tool(
+    "slack_get_channel_info",
+    "Gets metadata for one conversation visible to your connected Slack account.",
+    { channel },
+    ["channel"]
+  ),
+  tool(
+    "slack_list_channel_members",
+    "Lists one page of members in a visible channel or group conversation.",
+    { channel, cursor, limit: directoryPage },
+    ["channel"]
+  ),
+  tool("slack_list_users", "Lists one page of users in the connected Slack workspace.", {
+    cursor,
+    limit: directoryPage
+  }),
+  tool(
+    "slack_get_user_info",
+    "Gets a user's profile by their Slack user ID. Email is included only when Slack has granted that scope.",
+    { user: { type: "string" } },
+    ["user"]
+  ),
+  tool(
+    "slack_read_channel",
+    "Reads one page of at most 15 messages from a selected conversation. Slack history limits are shared across the workspace. No automatic pagination or backfill.",
+    {
+      channel,
+      cursor,
+      limit: historyPage,
+      oldest: timestamp,
+      latest: timestamp,
+      inclusive: { type: "boolean", default: false }
+    },
+    ["channel"]
+  ),
+  tool(
+    "slack_read_thread",
+    "Reads one page of at most 15 messages in a selected thread. Slack thread limits are shared across the workspace. No automatic pagination or backfill.",
+    {
+      channel,
+      ts: { ...timestamp, description: "Thread root message timestamp." },
+      cursor,
+      limit: historyPage
+    },
+    ["channel", "ts"]
+  ),
+  tool(
+    "slack_open_dm",
+    "Opens or resumes a direct message with one Slack user as your connected account.",
+    { user: { type: "string" } },
+    ["user"],
+    true
+  ),
+  tool(
+    "slack_send_message",
+    "Sends a message as your connected Slack account. Supply thread_ts to reply in a thread. Review the recipient and text before approving. An uncertain submission is never automatically retried.",
+    {
+      channel,
+      text: { type: "string", minLength: 1, maxLength: 4e4 },
+      thread_ts: { ...timestamp, description: "Optional thread root timestamp for a reply." },
+      unfurl_links: { type: "boolean", default: false },
+      unfurl_media: { type: "boolean", default: false }
+    },
+    ["channel", "text"],
+    true
+  )
+];
+var REQUIRED_ANY_SCOPES = {
+  slack_list_channels: conversationScopes,
+  slack_get_channel_info: conversationScopes,
+  slack_list_channel_members: ["channels:read", "groups:read", "mpim:read"],
+  slack_list_users: ["users:read"],
+  slack_get_user_info: ["users:read"],
+  slack_read_channel: historyScopes,
+  slack_read_thread: historyScopes,
+  slack_open_dm: ["im:write"],
+  slack_send_message: ["chat:write"]
+};
+function slackRestMcpToolsForScopes(scopes) {
+  const granted = new Set(normalizeSlackScopes(scopes));
+  return SLACK_REST_MCP_TOOLS.filter(
+    (entry) => REQUIRED_ANY_SCOPES[entry.name]?.some((scope) => granted.has(scope))
+  ).map((entry) => ({
+    ...entry,
+    inputSchema: {
+      ...entry.inputSchema,
+      required: [...entry.inputSchema.required],
+      properties: { ...entry.inputSchema.properties }
+    },
+    annotations: { ...entry.annotations }
+  }));
+}
+var SLACK_CONVERSATION_READ_SCOPE_BY_TYPE = {
+  public_channel: "channels:read",
+  private_channel: "groups:read",
+  im: "im:read",
+  mpim: "mpim:read"
+};
+
+export {
+  OFFICIAL_SLACK_MCP_URL,
+  SLACK_REST_API_BASE,
+  OPENGENI_SLACK_REST_USER_SCOPES,
+  normalizeSlackScopes,
+  SLACK_REST_MCP_TOOLS,
+  slackRestMcpToolsForScopes,
+  SLACK_CONVERSATION_READ_SCOPE_BY_TYPE
+};
+//# sourceMappingURL=chunk-MZLBPKFE.js.map

package/dist/chunk-MZLBPKFE.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/slack-rest-mcp.ts"],"sourcesContent":["/** The catalog and OAuth identity stay stable while calls use the ordinary Web API. */\nexport const OFFICIAL_SLACK_MCP_URL = \"https://mcp.slack.com/mcp\";\nexport const SLACK_REST_API_BASE = \"https://slack.com/api/\";\n\nexport const OPENGENI_SLACK_REST_USER_SCOPES = [\n  \"channels:read\",\n  \"groups:read\",\n  \"im:read\",\n  \"mpim:read\",\n  \"channels:history\",\n  \"groups:history\",\n  \"im:history\",\n  \"mpim:history\",\n  \"users:read\",\n  \"im:write\",\n  \"chat:write\",\n] as const;\n\n/** Slack returns comma-delimited scopes, including in existing saved grants. */\nexport function normalizeSlackScopes(\n  scopes: readonly string[] | string | undefined | null,\n): string[] {\n  return [\n    ...new Set(\n      (typeof scopes === \"string\" ? [scopes] : (scopes ?? []))\n        .flatMap((entry) => entry.split(/[\\s,]+/u))\n        .filter(Boolean),\n    ),\n  ].sort();\n}\n\nexport type SlackRestMcpTool = {\n  name: string;\n  description: string;\n  inputSchema: {\n    type: \"object\";\n    properties: Record<string, unknown>;\n    required: string[];\n    additionalProperties: false;\n  };\n  annotations: {\n    readOnlyHint: boolean;\n    destructiveHint: false;\n    idempotentHint: boolean;\n    openWorldHint: true;\n  };\n};\n\nconst conversationScopes = [\"channels:read\", \"groups:read\", \"im:read\", \"mpim:read\"];\nconst historyScopes = [\"channels:history\", \"groups:history\", \"im:history\", \"mpim:history\"];\nconst channel = { type: \"string\", description: \"Slack conversation ID, such as C123 or D123.\" };\nconst cursor = { type: \"string\", maxLength: 4096, description: \"Cursor from the previous page.\" };\nconst directoryPage = { type: \"integer\", minimum: 1, maximum: 100, default: 100 };\nconst historyPage = { type: \"integer\", minimum: 1, maximum: 15, default: 15 };\nconst timestamp = { type: \"string\", pattern: \"^[0-9]+\\\\.[0-9]+$\" };\n\nfunction tool(\n  name: string,\n  description: string,\n  properties: Record<string, unknown>,\n  required: string[] = [],\n  mutation = false,\n): SlackRestMcpTool {\n  return {\n    name,\n    description,\n    inputSchema: { type: \"object\", properties, required, additionalProperties: false },\n    annotations: {\n      readOnlyHint: !mutation,\n      destructiveHint: false,\n      idempotentHint: !mutation,\n      openWorldHint: true,\n    },\n  };\n}\n\n/** Static reviewed pilot surface. Each call reads only one explicitly requested page. */\nexport const SLACK_REST_MCP_TOOLS: SlackRestMcpTool[] = [\n  tool(\n    \"slack_list_channels\",\n    \"Lists one page of conversations visible to your connected Slack account. Conversation types without a granted read scope are omitted.\",\n    {\n      types: {\n        type: \"array\",\n        items: { type: \"string\", enum: [\"public_channel\", \"private_channel\", \"im\", \"mpim\"] },\n        minItems: 1,\n        maxItems: 4,\n      },\n      cursor,\n      limit: directoryPage,\n      exclude_archived: { type: \"boolean\", default: true },\n    },\n  ),\n  tool(\n    \"slack_get_channel_info\",\n    \"Gets metadata for one conversation visible to your connected Slack account.\",\n    { channel },\n    [\"channel\"],\n  ),\n  tool(\n    \"slack_list_channel_members\",\n    \"Lists one page of members in a visible channel or group conversation.\",\n    { channel, cursor, limit: directoryPage },\n    [\"channel\"],\n  ),\n  tool(\"slack_list_users\", \"Lists one page of users in the connected Slack workspace.\", {\n    cursor,\n    limit: directoryPage,\n  }),\n  tool(\n    \"slack_get_user_info\",\n    \"Gets a user's profile by their Slack user ID. Email is included only when Slack has granted that scope.\",\n    { user: { type: \"string\" } },\n    [\"user\"],\n  ),\n  tool(\n    \"slack_read_channel\",\n    \"Reads one page of at most 15 messages from a selected conversation. Slack history limits are shared across the workspace. No automatic pagination or backfill.\",\n    {\n      channel,\n      cursor,\n      limit: historyPage,\n      oldest: timestamp,\n      latest: timestamp,\n      inclusive: { type: \"boolean\", default: false },\n    },\n    [\"channel\"],\n  ),\n  tool(\n    \"slack_read_thread\",\n    \"Reads one page of at most 15 messages in a selected thread. Slack thread limits are shared across the workspace. No automatic pagination or backfill.\",\n    {\n      channel,\n      ts: { ...timestamp, description: \"Thread root message timestamp.\" },\n      cursor,\n      limit: historyPage,\n    },\n    [\"channel\", \"ts\"],\n  ),\n  tool(\n    \"slack_open_dm\",\n    \"Opens or resumes a direct message with one Slack user as your connected account.\",\n    { user: { type: \"string\" } },\n    [\"user\"],\n    true,\n  ),\n  tool(\n    \"slack_send_message\",\n    \"Sends a message as your connected Slack account. Supply thread_ts to reply in a thread. Review the recipient and text before approving. An uncertain submission is never automatically retried.\",\n    {\n      channel,\n      text: { type: \"string\", minLength: 1, maxLength: 40000 },\n      thread_ts: { ...timestamp, description: \"Optional thread root timestamp for a reply.\" },\n      unfurl_links: { type: \"boolean\", default: false },\n      unfurl_media: { type: \"boolean\", default: false },\n    },\n    [\"channel\", \"text\"],\n    true,\n  ),\n];\n\nconst REQUIRED_ANY_SCOPES: Readonly<Record<string, readonly string[]>> = {\n  slack_list_channels: conversationScopes,\n  slack_get_channel_info: conversationScopes,\n  slack_list_channel_members: [\"channels:read\", \"groups:read\", \"mpim:read\"],\n  slack_list_users: [\"users:read\"],\n  slack_get_user_info: [\"users:read\"],\n  slack_read_channel: historyScopes,\n  slack_read_thread: historyScopes,\n  slack_open_dm: [\"im:write\"],\n  slack_send_message: [\"chat:write\"],\n};\n\nexport function slackRestMcpToolsForScopes(scopes: readonly string[] | string): SlackRestMcpTool[] {\n  const granted = new Set(normalizeSlackScopes(scopes));\n  return SLACK_REST_MCP_TOOLS.filter((entry) =>\n    REQUIRED_ANY_SCOPES[entry.name]?.some((scope) => granted.has(scope)),\n  ).map((entry) => ({\n    ...entry,\n    inputSchema: {\n      ...entry.inputSchema,\n      required: [...entry.inputSchema.required],\n      properties: { ...entry.inputSchema.properties },\n    },\n    annotations: { ...entry.annotations },\n  }));\n}\n\nexport const SLACK_CONVERSATION_READ_SCOPE_BY_TYPE = {\n  public_channel: \"channels:read\",\n  private_channel: \"groups:read\",\n  im: \"im:read\",\n  mpim: \"mpim:read\",\n} as const;\n"],"mappings":"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","names":[]}

package/dist/{chunk-H5BVCZKF.js → chunk-NRMCVHAU.js}

@@ -3,10 +3,10 @@ import {
   decodeEditableArtifactMutationIntent,
   encodeEditableArtifactMutationIntent,
   hashEditableArtifactMutationIntentBytes
-} from "./chunk-TZ6YEYN4.js";
+} from "./chunk-NVJMJWLL.js";
 import {
   editableArtifactCodecFor
-} from "./chunk-FJBG5E4O.js";
+} from "./chunk-SIOU2K4U.js";
 import {
   DOCUMENT_ARTIFACT_COMMAND_MAX_COMMANDS,
   DOCUMENT_ARTIFACT_MAX_STRUCTURAL_COUNTER
@@ -21,10 +21,12 @@ import {
   fnv1a64,
   strictUtf8
 } from "./chunk-MYBZRDTY.js";
+import {
+  EDITABLE_ARTIFACT_SERIALIZED_COMMIT_VERSION
+} from "./chunk-PX3VCKAU.js";
 
 // src/editable-artifact-serialized-commit.ts
 import { bytesToHex } from "@noble/hashes/utils";
-var EDITABLE_ARTIFACT_SERIALIZED_COMMIT_VERSION = 1;
 var EDITABLE_ARTIFACT_SERIALIZED_COMMIT_MAX_BYTES = 8 * 1024 * 1024;
 var EDITABLE_ARTIFACT_NATIVE_RECEIPT_MAX_BYTES = 512 * 1024;
 var MAGIC = strictUtf8("OGAST001", "serialized commit magic");
@@ -372,11 +374,10 @@ function assertUnsharedBytes(value, label) {
 }
 
 export {
-  EDITABLE_ARTIFACT_SERIALIZED_COMMIT_VERSION,
   EDITABLE_ARTIFACT_SERIALIZED_COMMIT_MAX_BYTES,
   EDITABLE_ARTIFACT_NATIVE_RECEIPT_MAX_BYTES,
   encodeEditableArtifactSerializedCommit,
   decodeEditableArtifactSerializedCommit,
   assertCanonicalEditableArtifactSerializedCommit
 };
-//# sourceMappingURL=chunk-H5BVCZKF.js.map
+//# sourceMappingURL=chunk-NRMCVHAU.js.map

package/dist/chunk-NRMCVHAU.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/editable-artifact-serialized-commit.ts"],"sourcesContent":["import { bytesToHex } from \"@noble/hashes/utils\";\n\nimport {\n  ArtifactBinaryReader,\n  ArtifactBinaryWriter,\n  EDITABLE_ARTIFACT_BINARY_CHECKSUM_BYTES,\n  EDITABLE_ARTIFACT_BINARY_HEADER_BYTES,\n  decodeCountedEnvelope,\n  equalBytes,\n  fnv1a64,\n  strictUtf8,\n} from \"./editable-artifact-binary\";\nimport {\n  DOCUMENT_ARTIFACT_COMMAND_MAX_COMMANDS,\n  DOCUMENT_ARTIFACT_MAX_STRUCTURAL_COUNTER,\n} from \"./document-artifact-commands\";\nimport {\n  EDITABLE_ARTIFACT_INTENT_MAX_BYTES,\n  decodeEditableArtifactMutationIntent,\n  encodeEditableArtifactMutationIntent,\n  hashEditableArtifactMutationIntentBytes,\n  type EditableArtifactMutationIntent,\n} from \"./editable-artifacts\";\nimport { editableArtifactCodecFor } from \"./editable-artifact-codec-registry\";\nimport { EDITABLE_ARTIFACT_SERIALIZED_COMMIT_VERSION } from \"./editable-artifact-versions\";\n\nexport { EDITABLE_ARTIFACT_SERIALIZED_COMMIT_VERSION } from \"./editable-artifact-versions\";\nexport const EDITABLE_ARTIFACT_SERIALIZED_COMMIT_MAX_BYTES = 8 * 1024 * 1024;\nexport const EDITABLE_ARTIFACT_NATIVE_RECEIPT_MAX_BYTES = 512 * 1024;\n\nconst MAGIC = strictUtf8(\"OGAST001\", \"serialized commit magic\");\nconst SHA256_TEXT = /^sha256:[0-9a-f]{64}$/u;\nconst STABLE_ID = /^[0-9a-f]{32}$/u;\nconst DOCUMENT_RECEIPT_MAGIC = \"OGADR001\";\nconst PRESENTATION_RECEIPT_MAGIC = strictUtf8(\"OGAPR001\", \"presentation receipt magic\");\nconst DOCUMENT_RECEIPT_VERSION = 1;\nconst PRESENTATION_RECEIPT_VERSION = 1;\nconst DOCUMENT_CREATED_IDS_PER_COMMAND = 7;\nconst DOCUMENT_ID_BYTES = 17;\nconst PRESENTATION_RECEIPT_BYTES = 32;\nconst MODALITY_TAG = Object.freeze({ document: 1, presentation: 2 } as const);\n\nexport type EditableArtifactSerializedModality = \"document\" | \"presentation\";\n\nexport type EditableArtifactNativeReceiptSummary =\n  | Readonly<{\n      modality: \"document\";\n      revision: number;\n      commandCount: number;\n      createdIdCount: number;\n    }>\n  | Readonly<{\n      modality: \"presentation\";\n      revision: number;\n      commandCount: number;\n    }>;\n\nexport type EditableArtifactSerializedCommitInput = Readonly<{\n  modality: EditableArtifactSerializedModality;\n  transactionId: string;\n  parentHeadSequence: number;\n  resultHeadSequence: number;\n  /** Native model revision before applying this non-empty command batch. */\n  priorNativeRevision: number;\n  priorStateHash: string;\n  stateHash: string;\n  /** Exact canonical OGATX001 bytes accepted by the server. */\n  intentBytes: Uint8Array;\n  /** Exact canonical OGADR001 or OGAPR001 bytes returned by the native kernel. */\n  nativeReceiptBytes: Uint8Array;\n}>;\n\nexport type EditableArtifactSerializedCommitSummary = Readonly<{\n  commitProtocolVersion: typeof EDITABLE_ARTIFACT_SERIALIZED_COMMIT_VERSION;\n  modality: EditableArtifactSerializedModality;\n  transactionId: string;\n  parentHeadSequence: number;\n  resultHeadSequence: number;\n  priorNativeRevision: number;\n  priorStateHash: string;\n  stateHash: string;\n  requestHash: string;\n  /** Canonical client intent nested in this authoritative commit. */\n  intent: EditableArtifactMutationIntent;\n  intentBytes: Uint8Array;\n  nativeReceiptBytes: Uint8Array;\n  nativeReceipt: EditableArtifactNativeReceiptSummary;\n}>;\n\n/**\n * Server-only encoder for one authoritative, strictly serialized commit.\n * Client identity remains solely in the exact nested OGATX envelope.\n */\nexport function encodeEditableArtifactSerializedCommit(\n  input: EditableArtifactSerializedCommitInput,\n): Uint8Array {\n  const normalized = normalizeSerializedCommit(input);\n  const payload = new ArtifactBinaryWriter(\n    EDITABLE_ARTIFACT_SERIALIZED_COMMIT_MAX_BYTES -\n      EDITABLE_ARTIFACT_BINARY_HEADER_BYTES -\n      EDITABLE_ARTIFACT_BINARY_CHECKSUM_BYTES,\n  );\n  payload.stableId(normalized.transactionId, \"serialized transaction id\");\n  payload.u64(normalized.parentHeadSequence);\n  payload.u64(normalized.resultHeadSequence);\n  payload.u64(normalized.priorNativeRevision);\n  payload.bytes(hashBytes(normalized.priorStateHash));\n  payload.bytes(hashBytes(normalized.stateHash));\n  payload.u32(normalized.intentBytes.byteLength);\n  payload.u32(normalized.nativeReceiptBytes.byteLength);\n  payload.bytes(normalized.intentBytes);\n  payload.bytes(normalized.nativeReceiptBytes);\n\n  const payloadBytes = payload.finish();\n  const output = new ArtifactBinaryWriter(EDITABLE_ARTIFACT_SERIALIZED_COMMIT_MAX_BYTES);\n  output.bytes(MAGIC);\n  output.u16(EDITABLE_ARTIFACT_SERIALIZED_COMMIT_VERSION);\n  output.u16(0);\n  output.u32(MODALITY_TAG[normalized.modality]);\n  output.u64(payloadBytes.byteLength);\n  output.bytes(payloadBytes);\n  output.u64(fnv1a64(output.view()));\n  return output.finish();\n}\n\n/** Durable modality must be selected before any nested receipt/command decode. */\nexport function decodeEditableArtifactSerializedCommit(\n  bytes: Uint8Array,\n  durableModality: EditableArtifactSerializedModality,\n): EditableArtifactSerializedCommitSummary {\n  assertUnsharedBytes(bytes, \"serialized commit\");\n  const modality = serializedModality(durableModality);\n  if (bytes.byteLength > EDITABLE_ARTIFACT_SERIALIZED_COMMIT_MAX_BYTES) {\n    throw new RangeError(\"serialized commit exceeds its byte limit\");\n  }\n  if (\n    bytes.byteLength <\n    EDITABLE_ARTIFACT_BINARY_HEADER_BYTES + EDITABLE_ARTIFACT_BINARY_CHECKSUM_BYTES\n  ) {\n    throw new TypeError(\"truncated serialized commit envelope\");\n  }\n  const header = new ArtifactBinaryReader(bytes);\n  if (!equalBytes(header.bytes(8), MAGIC)) {\n    throw new TypeError(\"invalid serialized commit magic\");\n  }\n  if (header.u16() !== EDITABLE_ARTIFACT_SERIALIZED_COMMIT_VERSION) {\n    throw new TypeError(\"unsupported serialized commit version\");\n  }\n  if (header.u16() !== 0) {\n    throw new TypeError(\"reserved serialized commit flags must be zero\");\n  }\n  if (header.u32() !== MODALITY_TAG[modality]) {\n    throw new TypeError(\"serialized commit modality disagrees with durable artifact\");\n  }\n  const payloadLength = header.u64Safe(\"serialized commit payload length\");\n  const expectedLength =\n    EDITABLE_ARTIFACT_BINARY_HEADER_BYTES + payloadLength + EDITABLE_ARTIFACT_BINARY_CHECKSUM_BYTES;\n  if (bytes.byteLength < expectedLength) {\n    throw new TypeError(\"truncated serialized commit payload\");\n  }\n  if (bytes.byteLength > expectedLength) {\n    throw new TypeError(\"serialized commit contains trailing bytes\");\n  }\n  const payloadBytes = header.bytes(payloadLength);\n  const checksum = header.u64BigInt();\n  header.done();\n  if (\n    checksum !==\n    fnv1a64(bytes.subarray(0, bytes.byteLength - EDITABLE_ARTIFACT_BINARY_CHECKSUM_BYTES))\n  ) {\n    throw new TypeError(\"serialized commit checksum does not match\");\n  }\n\n  const payload = new ArtifactBinaryReader(payloadBytes);\n  const transactionId = payload.stableId(\"serialized transaction id\");\n  const parentHeadSequence = payload.u64Safe(\"serialized parent head sequence\");\n  const resultHeadSequence = payload.u64Safe(\"serialized result head sequence\");\n  const priorNativeRevision = payload.u64Safe(\"serialized prior native revision\");\n  const priorStateHash = stateHashText(payload.bytes(32));\n  const stateHash = stateHashText(payload.bytes(32));\n  const intentLength = payload.count(\n    EDITABLE_ARTIFACT_INTENT_MAX_BYTES,\n    \"serialized intent bytes\",\n    1,\n  );\n  const receiptLength = payload.count(\n    EDITABLE_ARTIFACT_NATIVE_RECEIPT_MAX_BYTES,\n    \"serialized native receipt bytes\",\n    1,\n  );\n  if (payload.remaining !== intentLength + receiptLength) {\n    throw new TypeError(\"serialized commit nested byte lengths are inconsistent\");\n  }\n  const intentBytes = payload.bytes(intentLength).slice();\n  const nativeReceiptBytes = payload.bytes(receiptLength).slice();\n  payload.done();\n\n  const normalized = normalizeSerializedCommit({\n    modality,\n    transactionId,\n    parentHeadSequence,\n    resultHeadSequence,\n    priorNativeRevision,\n    priorStateHash,\n    stateHash,\n    intentBytes,\n    nativeReceiptBytes,\n  });\n  const canonical = encodeEditableArtifactSerializedCommit(normalized);\n  if (!equalBytes(bytes, canonical)) {\n    throw new TypeError(\"serialized commit is not canonically encoded\");\n  }\n  return Object.freeze({\n    commitProtocolVersion: EDITABLE_ARTIFACT_SERIALIZED_COMMIT_VERSION,\n    modality,\n    transactionId,\n    parentHeadSequence,\n    resultHeadSequence,\n    priorNativeRevision,\n    priorStateHash,\n    stateHash,\n    requestHash: normalized.requestHash,\n    intent: normalized.intent,\n    intentBytes,\n    nativeReceiptBytes,\n    nativeReceipt: normalized.nativeReceipt,\n  });\n}\n\nexport function assertCanonicalEditableArtifactSerializedCommit(\n  bytes: Uint8Array,\n  durableModality: EditableArtifactSerializedModality,\n): void {\n  decodeEditableArtifactSerializedCommit(bytes, durableModality);\n}\n\ntype NormalizedSerializedCommit = EditableArtifactSerializedCommitInput &\n  Readonly<{\n    requestHash: string;\n    intent: EditableArtifactMutationIntent;\n    nativeReceipt: EditableArtifactNativeReceiptSummary;\n  }>;\n\nfunction normalizeSerializedCommit(\n  input: EditableArtifactSerializedCommitInput,\n): NormalizedSerializedCommit {\n  const modality = serializedModality(input.modality);\n  const transactionId = canonicalStableId(input.transactionId, \"serialized transaction id\");\n  const parentHeadSequence = safeSequence(\n    input.parentHeadSequence,\n    \"serialized parent head sequence\",\n  );\n  const resultHeadSequence = safeSequence(\n    input.resultHeadSequence,\n    \"serialized result head sequence\",\n  );\n  if (resultHeadSequence !== parentHeadSequence + 1) {\n    throw new TypeError(\"serialized commit must advance the durable head exactly once\");\n  }\n  const priorNativeRevision = safeSequence(\n    input.priorNativeRevision,\n    \"serialized prior native revision\",\n  );\n  const priorStateHash = canonicalSha256(input.priorStateHash, \"serialized prior state hash\");\n  const stateHash = canonicalSha256(input.stateHash, \"serialized resulting state hash\");\n  assertUnsharedBytes(input.intentBytes, \"serialized intent\");\n  assertUnsharedBytes(input.nativeReceiptBytes, \"serialized native receipt\");\n  if (\n    input.intentBytes.byteLength < 1 ||\n    input.intentBytes.byteLength > EDITABLE_ARTIFACT_INTENT_MAX_BYTES\n  ) {\n    throw new RangeError(\"serialized intent bytes exceed their limit\");\n  }\n  if (\n    input.nativeReceiptBytes.byteLength < 1 ||\n    input.nativeReceiptBytes.byteLength > EDITABLE_ARTIFACT_NATIVE_RECEIPT_MAX_BYTES\n  ) {\n    throw new RangeError(\"serialized native receipt bytes exceed their limit\");\n  }\n  const intentBytes = input.intentBytes.slice();\n  const decodedIntent = decodeEditableArtifactMutationIntent(intentBytes);\n  if (!equalBytes(intentBytes, encodeEditableArtifactMutationIntent(decodedIntent))) {\n    throw new TypeError(\"nested serialized intent is not canonical OGATX001\");\n  }\n  if (\n    decodedIntent.causalBase.length !== 0 ||\n    decodedIntent.selectiveUndoOperationIds.length !== 0\n  ) {\n    throw new TypeError(\"serialized commits cannot carry CRDT causality or selective undo\");\n  }\n  if (decodedIntent.observedHeadSequence !== parentHeadSequence) {\n    throw new TypeError(\"serialized intent observed head does not match its parent\");\n  }\n  const descriptor = editableArtifactCodecFor({\n    durableModality: modality,\n    modelSchemaVersion: decodedIntent.modelSchemaVersion,\n    commandProtocolVersion: decodedIntent.commandProtocolVersion,\n  });\n  descriptor.command.assertCanonical(decodedIntent.commandBytes);\n  const commandCount = decodedCommandCount(descriptor.command.decode(decodedIntent.commandBytes));\n  if (commandCount < 1) {\n    throw new TypeError(\"serialized commits require a non-empty command batch\");\n  }\n  const nativeReceiptBytes = input.nativeReceiptBytes.slice();\n  const nativeReceipt = decodeNativeReceipt(modality, nativeReceiptBytes, commandCount);\n  if (modality === \"presentation\") {\n    if (nativeReceipt.revision !== priorNativeRevision + 1) {\n      throw new TypeError(\n        \"presentation receipt must advance its prior native revision exactly once\",\n      );\n    }\n    if (stateHash === priorStateHash) {\n      throw new TypeError(\"presentation commit must change its canonical state hash\");\n    }\n  } else if (nativeReceipt.revision === priorNativeRevision) {\n    if (stateHash !== priorStateHash) {\n      throw new TypeError(\"document no-op receipt cannot change the canonical state hash\");\n    }\n  } else {\n    if (nativeReceipt.revision !== priorNativeRevision + 1) {\n      throw new TypeError(\n        \"document receipt must preserve or advance its prior native revision once\",\n      );\n    }\n    if (stateHash === priorStateHash) {\n      throw new TypeError(\"document revision advance must change the canonical state hash\");\n    }\n  }\n  const requestHash = hashEditableArtifactMutationIntentBytes(intentBytes);\n  return Object.freeze({\n    modality,\n    transactionId,\n    parentHeadSequence,\n    resultHeadSequence,\n    priorNativeRevision,\n    priorStateHash,\n    stateHash,\n    intentBytes,\n    nativeReceiptBytes,\n    requestHash,\n    intent: decodedIntent,\n    nativeReceipt,\n  });\n}\n\nfunction decodeNativeReceipt(\n  modality: EditableArtifactSerializedModality,\n  bytes: Uint8Array,\n  expectedCommandCount: number,\n): EditableArtifactNativeReceiptSummary {\n  return modality === \"document\"\n    ? decodeDocumentReceipt(bytes, expectedCommandCount)\n    : decodePresentationReceipt(bytes, expectedCommandCount);\n}\n\nfunction decodeDocumentReceipt(\n  bytes: Uint8Array,\n  expectedCommandCount: number,\n): Extract<EditableArtifactNativeReceiptSummary, { modality: \"document\" }> {\n  const envelope = decodeCountedEnvelope(\n    bytes,\n    DOCUMENT_RECEIPT_MAGIC,\n    DOCUMENT_RECEIPT_VERSION,\n    EDITABLE_ARTIFACT_NATIVE_RECEIPT_MAX_BYTES,\n    DOCUMENT_ARTIFACT_COMMAND_MAX_COMMANDS,\n  );\n  const payload = new ArtifactBinaryReader(envelope.payload);\n  const revision = payload.u64Safe(\"document receipt revision\");\n  const commandCount = payload.u32();\n  if (commandCount !== envelope.count || commandCount !== expectedCommandCount) {\n    throw new TypeError(\"document receipt command count does not match its intent\");\n  }\n  const maximumCreatedIds = commandCount * DOCUMENT_CREATED_IDS_PER_COMMAND;\n  const createdIdCount = payload.count(\n    maximumCreatedIds,\n    \"document receipt created ids\",\n    DOCUMENT_ID_BYTES,\n  );\n  for (let index = 0; index < createdIdCount; index += 1) {\n    const tag = payload.u8();\n    if (tag < 1 || tag > 8) {\n      throw new TypeError(\"document receipt contains an invalid id kind\");\n    }\n    payload.u64BigInt();\n    const counter = payload.u64BigInt();\n    if (counter === 0n || counter > BigInt(DOCUMENT_ARTIFACT_MAX_STRUCTURAL_COUNTER)) {\n      throw new TypeError(\"document receipt contains an invalid id counter\");\n    }\n  }\n  payload.done(\"document receipt contains trailing bytes\");\n  return Object.freeze({\n    modality: \"document\",\n    revision,\n    commandCount,\n    createdIdCount,\n  });\n}\n\nfunction decodePresentationReceipt(\n  bytes: Uint8Array,\n  expectedCommandCount: number,\n): Extract<EditableArtifactNativeReceiptSummary, { modality: \"presentation\" }> {\n  if (bytes.byteLength !== PRESENTATION_RECEIPT_BYTES) {\n    throw new TypeError(\n      bytes.byteLength < PRESENTATION_RECEIPT_BYTES\n        ? \"truncated presentation receipt\"\n        : \"presentation receipt contains trailing bytes\",\n    );\n  }\n  const reader = new ArtifactBinaryReader(bytes);\n  if (!equalBytes(reader.bytes(8), PRESENTATION_RECEIPT_MAGIC)) {\n    throw new TypeError(\"invalid presentation receipt magic\");\n  }\n  if (reader.u16() !== PRESENTATION_RECEIPT_VERSION) {\n    throw new TypeError(\"unsupported presentation receipt version\");\n  }\n  if (reader.u16() !== 0) {\n    throw new TypeError(\"reserved presentation receipt flags must be zero\");\n  }\n  const revision = reader.u64Safe(\"presentation receipt revision\");\n  const commandCount = reader.u32();\n  if (commandCount !== expectedCommandCount) {\n    throw new TypeError(\"presentation receipt command count does not match its intent\");\n  }\n  const checksum = reader.u64BigInt();\n  reader.done();\n  if (\n    checksum !==\n    fnv1a64(bytes.subarray(0, bytes.byteLength - EDITABLE_ARTIFACT_BINARY_CHECKSUM_BYTES))\n  ) {\n    throw new TypeError(\"presentation receipt checksum does not match\");\n  }\n  return Object.freeze({ modality: \"presentation\", revision, commandCount });\n}\n\nfunction decodedCommandCount(value: unknown): number {\n  if (typeof value !== \"object\" || value === null || Array.isArray(value)) {\n    throw new TypeError(\"serialized command decoder returned an invalid batch\");\n  }\n  const descriptor = Object.getOwnPropertyDescriptor(value, \"commands\");\n  if (!descriptor || !(\"value\" in descriptor) || !Array.isArray(descriptor.value)) {\n    throw new TypeError(\"serialized command decoder returned an invalid batch\");\n  }\n  return descriptor.value.length;\n}\n\nfunction serializedModality(value: unknown): EditableArtifactSerializedModality {\n  if (value !== \"document\" && value !== \"presentation\") {\n    throw new TypeError(\"serialized commit modality is invalid\");\n  }\n  return value;\n}\n\nfunction canonicalStableId(value: unknown, label: string): string {\n  if (typeof value !== \"string\" || !STABLE_ID.test(value) || /^0+$/u.test(value)) {\n    throw new TypeError(`${label} must be a nonzero lowercase 128-bit hexadecimal id`);\n  }\n  return value;\n}\n\nfunction canonicalSha256(value: unknown, label: string): string {\n  if (typeof value !== \"string\" || !SHA256_TEXT.test(value)) {\n    throw new TypeError(`${label} must be canonical sha256 text`);\n  }\n  return value;\n}\n\nfunction safeSequence(value: unknown, label: string): number {\n  if (typeof value !== \"number\" || !Number.isSafeInteger(value) || value < 0) {\n    throw new TypeError(`${label} must be a nonnegative safe integer`);\n  }\n  return value;\n}\n\nfunction hashBytes(value: string): Uint8Array {\n  const hex = value.slice(\"sha256:\".length);\n  const bytes = new Uint8Array(32);\n  for (let index = 0; index < bytes.byteLength; index += 1) {\n    bytes[index] = Number.parseInt(hex.slice(index * 2, index * 2 + 2), 16);\n  }\n  return bytes;\n}\n\nfunction stateHashText(value: Uint8Array): string {\n  return `sha256:${bytesToHex(value)}`;\n}\n\nfunction assertUnsharedBytes(value: unknown, label: string): asserts value is Uint8Array {\n  if (!(value instanceof Uint8Array)) {\n    throw new TypeError(`${label} bytes must be a Uint8Array`);\n  }\n  if (typeof SharedArrayBuffer !== \"undefined\" && value.buffer instanceof SharedArrayBuffer) {\n    throw new TypeError(`${label} bytes must not use shared mutable memory`);\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-TZ6YEYN4.js → chunk-NVJMJWLL.js}

@@ -2,6 +2,7 @@
 import { sha256 } from "@noble/hashes/sha256";
 import { bytesToHex } from "@noble/hashes/utils";
 var EDITABLE_ARTIFACT_INTENT_VERSION = 1;
+var EDITABLE_ARTIFACT_INTENT_PROTOCOL_VERSION = 1;
 var EDITABLE_ARTIFACT_INTENT_MAX_BYTES = 5 * 1024 * 1024;
 var EDITABLE_ARTIFACT_COMMAND_MAX_BYTES = 4 * 1024 * 1024;
 var EDITABLE_ARTIFACT_KERNEL_VERSION_MAX_BYTES = 512;
@@ -371,6 +372,7 @@ var BinaryReader = class {
 
 export {
   EDITABLE_ARTIFACT_INTENT_VERSION,
+  EDITABLE_ARTIFACT_INTENT_PROTOCOL_VERSION,
   EDITABLE_ARTIFACT_INTENT_MAX_BYTES,
   EDITABLE_ARTIFACT_COMMAND_MAX_BYTES,
   EDITABLE_ARTIFACT_KERNEL_VERSION_MAX_BYTES,
@@ -383,4 +385,4 @@ export {
   hashEditableArtifactMutationIntent,
   assertEditableArtifactRequestHash
 };
-//# sourceMappingURL=chunk-TZ6YEYN4.js.map
+//# sourceMappingURL=chunk-NVJMJWLL.js.map

package/dist/chunk-NVJMJWLL.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/editable-artifacts.ts"],"sourcesContent":["import { sha256 } from \"@noble/hashes/sha256\";\nimport { bytesToHex } from \"@noble/hashes/utils\";\n\nexport * from \"./spreadsheet-artifact-commands\";\nexport * from \"./spreadsheet-artifact-query\";\nexport * from \"./editable-artifact-causal-frontier\";\nexport * from \"./document-artifact-commands\";\nexport * from \"./presentation-artifact-commands\";\nexport * from \"./editable-artifact-codec-registry\";\n\nexport const EDITABLE_ARTIFACT_INTENT_VERSION = 1 as const;\n/** Semantic protocol carried inside the unchanged OGATX001 envelope. */\nexport const EDITABLE_ARTIFACT_INTENT_PROTOCOL_VERSION = 1 as const;\nexport const EDITABLE_ARTIFACT_INTENT_MAX_BYTES = 5 * 1024 * 1024;\nexport const EDITABLE_ARTIFACT_COMMAND_MAX_BYTES = 4 * 1024 * 1024;\nexport const EDITABLE_ARTIFACT_KERNEL_VERSION_MAX_BYTES = 512;\n/** Largest durable snapshot every supported browser/WASM client can open. */\nexport const EDITABLE_ARTIFACT_PRODUCT_MAX_SNAPSHOT_BYTES = 64 * 1024 * 1024;\nexport const EDITABLE_ARTIFACT_INTENT_MAX_CAUSAL_ACTORS = 1_024;\nexport const EDITABLE_ARTIFACT_INTENT_MAX_UNDO_TARGETS = 10_000;\n\nconst MAGIC = new TextEncoder().encode(\"OGATX001\");\nconst textEncoder = new TextEncoder();\nconst textDecoder = new TextDecoder(\"utf-8\", { fatal: true });\nconst STABLE_ID = /^[0-9a-f]{32}$/u;\nconst REPLICA_ID = /^[0-9a-f]{16}$/u;\nconst CLIENT_TRANSACTION_ID = /^[A-Za-z0-9._:-]{1,200}$/u;\nconst REQUEST_HASH = /^sha256:[0-9a-f]{64}$/u;\n\nexport type EditableArtifactCausalEntry = Readonly<{\n  replicaId: string;\n  counter: number;\n}>;\n\n/**\n * Exact client-authored mutation identity. Scope and actor authority are\n * deliberately absent: the server derives them and binds them in the\n * idempotency lookup tuple instead of trusting client bytes.\n */\nexport type EditableArtifactMutationIntent = Readonly<{\n  envelopeVersion: typeof EDITABLE_ARTIFACT_INTENT_VERSION;\n  protocolVersion: number;\n  modelSchemaVersion: number;\n  commandProtocolVersion: number;\n  artifactId: string;\n  clientTransactionId: string;\n  replicaId: string;\n  replicaCounter: number;\n  previousLocalTransactionId: string | null;\n  observedHeadSequence: number;\n  causalBase: readonly EditableArtifactCausalEntry[];\n  selectiveUndoOperationIds: readonly string[];\n  commandBytes: Uint8Array;\n}>;\n\nexport function encodeEditableArtifactMutationIntent(\n  input: EditableArtifactMutationIntent,\n): Uint8Array {\n  // The writer owns the emitted bytes, so a second eager copy of a potentially\n  // multi-megabyte command block would add no safety.\n  const intent = normalizeIntent(input, false);\n  const writer = new BinaryWriter(EDITABLE_ARTIFACT_INTENT_MAX_BYTES);\n  writer.bytes(MAGIC);\n  writer.u16(intent.envelopeVersion);\n  writer.u16(intent.protocolVersion);\n  writer.u16(intent.modelSchemaVersion);\n  writer.u16(intent.commandProtocolVersion);\n  writer.string(intent.artifactId);\n  writer.string(intent.clientTransactionId);\n  writer.string(intent.replicaId);\n  writer.u64(intent.replicaCounter);\n  writer.u8(intent.previousLocalTransactionId === null ? 0 : 1);\n  if (intent.previousLocalTransactionId !== null) {\n    writer.string(intent.previousLocalTransactionId);\n  }\n  writer.u64(intent.observedHeadSequence);\n  writer.u16(intent.causalBase.length);\n  for (const entry of intent.causalBase) {\n    writer.string(entry.replicaId);\n    writer.u64(entry.counter);\n  }\n  writer.u16(intent.selectiveUndoOperationIds.length);\n  for (const operationId of intent.selectiveUndoOperationIds) writer.string(operationId);\n  writer.byteBlock(intent.commandBytes);\n  return writer.finish();\n}\n\nexport function decodeEditableArtifactMutationIntent(\n  bytes: Uint8Array,\n): EditableArtifactMutationIntent {\n  return parseEditableArtifactMutationIntent(bytes, true);\n}\n\nfunction parseEditableArtifactMutationIntent(\n  bytes: Uint8Array,\n  copyCommandBytes: boolean,\n): EditableArtifactMutationIntent {\n  if (!(bytes instanceof Uint8Array)) throw new TypeError(\"intent bytes must be a Uint8Array\");\n  if (bytes.byteLength > EDITABLE_ARTIFACT_INTENT_MAX_BYTES) {\n    throw new RangeError(\"editable artifact intent exceeds its byte limit\");\n  }\n  const reader = new BinaryReader(bytes);\n  const magic = reader.bytes(MAGIC.byteLength);\n  if (!equalBytes(magic, MAGIC)) throw new TypeError(\"invalid editable artifact intent magic\");\n  const envelopeVersion = reader.u16();\n  if (envelopeVersion !== EDITABLE_ARTIFACT_INTENT_VERSION) {\n    throw new TypeError(`unsupported editable artifact intent version: ${envelopeVersion}`);\n  }\n  const protocolVersion = reader.u16();\n  const modelSchemaVersion = reader.u16();\n  const commandProtocolVersion = reader.u16();\n  const artifactId = reader.string();\n  const clientTransactionId = reader.string();\n  const replicaId = reader.string();\n  const replicaCounter = reader.u64();\n  const predecessorFlag = reader.u8();\n  if (predecessorFlag > 1) throw new TypeError(\"invalid predecessor presence flag\");\n  const previousLocalTransactionId = predecessorFlag === 1 ? reader.string() : null;\n  const observedHeadSequence = reader.u64();\n  const causalCount = reader.u16();\n  if (causalCount > EDITABLE_ARTIFACT_INTENT_MAX_CAUSAL_ACTORS) {\n    throw new RangeError(\"editable artifact causal base exceeds its actor limit\");\n  }\n  const causalBase: EditableArtifactCausalEntry[] = [];\n  let previousReplicaId = \"\";\n  for (let index = 0; index < causalCount; index += 1) {\n    const causalReplicaId = reader.string();\n    if (causalReplicaId <= previousReplicaId) {\n      throw new TypeError(\"causal base replica ids must be unique and canonically sorted\");\n    }\n    previousReplicaId = causalReplicaId;\n    causalBase.push(Object.freeze({ replicaId: causalReplicaId, counter: reader.u64() }));\n  }\n  const undoCount = reader.u16();\n  if (undoCount > EDITABLE_ARTIFACT_INTENT_MAX_UNDO_TARGETS) {\n    throw new RangeError(\"editable artifact undo targets exceed their limit\");\n  }\n  const selectiveUndoOperationIds: string[] = [];\n  let previousOperationId = \"\";\n  for (let index = 0; index < undoCount; index += 1) {\n    const operationId = reader.string();\n    if (operationId <= previousOperationId) {\n      throw new TypeError(\"undo operation ids must be unique and canonically sorted\");\n    }\n    previousOperationId = operationId;\n    selectiveUndoOperationIds.push(operationId);\n  }\n  const commandBytes = reader.byteBlock(EDITABLE_ARTIFACT_COMMAND_MAX_BYTES);\n  reader.done();\n  return normalizeIntent(\n    {\n      envelopeVersion: EDITABLE_ARTIFACT_INTENT_VERSION,\n      protocolVersion,\n      modelSchemaVersion,\n      commandProtocolVersion,\n      artifactId,\n      clientTransactionId,\n      replicaId,\n      replicaCounter,\n      previousLocalTransactionId,\n      observedHeadSequence,\n      causalBase,\n      selectiveUndoOperationIds,\n      commandBytes,\n    },\n    copyCommandBytes,\n  );\n}\n\nexport function hashEditableArtifactMutationIntentBytes(bytes: Uint8Array): string {\n  // Decode first so noncanonical or malformed bytes can never acquire a valid\n  // application-level request hash merely because SHA-256 accepts any bytes.\n  parseEditableArtifactMutationIntent(bytes, false);\n  return `sha256:${bytesToHex(sha256(bytes))}`;\n}\n\nexport function hashEditableArtifactMutationIntent(intent: EditableArtifactMutationIntent): {\n  bytes: Uint8Array;\n  requestHash: string;\n} {\n  const bytes = encodeEditableArtifactMutationIntent(intent);\n  return { bytes, requestHash: `sha256:${bytesToHex(sha256(bytes))}` };\n}\n\nexport function assertEditableArtifactRequestHash(value: string): string {\n  if (!REQUEST_HASH.test(value)) {\n    throw new TypeError(\"editable artifact request hash must be canonical sha256 text\");\n  }\n  return value;\n}\n\nfunction normalizeIntent(\n  input: EditableArtifactMutationIntent,\n  copyCommandBytes = true,\n): EditableArtifactMutationIntent {\n  if (!isPlainRecord(input)) throw new TypeError(\"editable artifact intent must be a plain record\");\n  if (input.envelopeVersion !== EDITABLE_ARTIFACT_INTENT_VERSION) {\n    throw new TypeError(\"editable artifact intent envelope version must be 1\");\n  }\n  const protocolVersion = positiveU16(input.protocolVersion, \"protocolVersion\");\n  const modelSchemaVersion = positiveU16(input.modelSchemaVersion, \"modelSchemaVersion\");\n  const commandProtocolVersion = positiveU16(\n    input.commandProtocolVersion,\n    \"commandProtocolVersion\",\n  );\n  const artifactId = stableId(input.artifactId, \"artifactId\");\n  const clientTransactionId = portableTransactionId(\n    input.clientTransactionId,\n    \"clientTransactionId\",\n  );\n  const replicaId = replicaIdentity(input.replicaId, \"replicaId\");\n  const replicaCounter = positiveSafeInteger(input.replicaCounter, \"replicaCounter\");\n  const previousLocalTransactionId =\n    input.previousLocalTransactionId === null\n      ? null\n      : portableTransactionId(input.previousLocalTransactionId, \"previousLocalTransactionId\");\n  const observedHeadSequence = nonnegativeSafeInteger(\n    input.observedHeadSequence,\n    \"observedHeadSequence\",\n  );\n  if (!Array.isArray(input.causalBase)) throw new TypeError(\"causalBase must be an array\");\n  if (input.causalBase.length > EDITABLE_ARTIFACT_INTENT_MAX_CAUSAL_ACTORS) {\n    throw new RangeError(\"editable artifact causal base exceeds its actor limit\");\n  }\n  const causalByReplica = new Map<string, number>();\n  for (const entry of input.causalBase) {\n    if (!isPlainRecord(entry)) throw new TypeError(\"causal entries must be plain records\");\n    const causalReplicaId = replicaIdentity(entry.replicaId, \"causal replicaId\");\n    if (causalByReplica.has(causalReplicaId)) throw new TypeError(\"duplicate causal replicaId\");\n    causalByReplica.set(\n      causalReplicaId,\n      positiveSafeInteger(entry.counter, `causal counter for ${causalReplicaId}`),\n    );\n  }\n  const causalBase = [...causalByReplica]\n    .sort(([left], [right]) => compareCodeUnits(left, right))\n    .map(([causalReplicaId, counter]) => Object.freeze({ replicaId: causalReplicaId, counter }));\n  if (!Array.isArray(input.selectiveUndoOperationIds)) {\n    throw new TypeError(\"selectiveUndoOperationIds must be an array\");\n  }\n  if (input.selectiveUndoOperationIds.length > EDITABLE_ARTIFACT_INTENT_MAX_UNDO_TARGETS) {\n    throw new RangeError(\"editable artifact undo targets exceed their limit\");\n  }\n  const undoSet = new Set<string>();\n  for (const value of input.selectiveUndoOperationIds) {\n    const operationId = stableId(value, \"selective undo operation id\");\n    if (undoSet.has(operationId)) throw new TypeError(\"duplicate selective undo operation id\");\n    undoSet.add(operationId);\n  }\n  const selectiveUndoOperationIds = [...undoSet].sort(compareCodeUnits);\n  if (!(input.commandBytes instanceof Uint8Array)) {\n    throw new TypeError(\"commandBytes must be a Uint8Array\");\n  }\n  if (input.commandBytes.byteLength < 1) throw new TypeError(\"commandBytes must not be empty\");\n  if (input.commandBytes.byteLength > EDITABLE_ARTIFACT_COMMAND_MAX_BYTES) {\n    throw new RangeError(\"commandBytes exceeds its byte limit\");\n  }\n  return Object.freeze({\n    envelopeVersion: EDITABLE_ARTIFACT_INTENT_VERSION,\n    protocolVersion,\n    modelSchemaVersion,\n    commandProtocolVersion,\n    artifactId,\n    clientTransactionId,\n    replicaId,\n    replicaCounter,\n    previousLocalTransactionId,\n    observedHeadSequence,\n    causalBase: Object.freeze(causalBase),\n    selectiveUndoOperationIds: Object.freeze(selectiveUndoOperationIds),\n    commandBytes: copyCommandBytes ? input.commandBytes.slice() : input.commandBytes,\n  });\n}\n\nfunction isPlainRecord(value: unknown): value is Record<string, unknown> {\n  return (\n    typeof value === \"object\" && value !== null && Object.getPrototypeOf(value) === Object.prototype\n  );\n}\n\nfunction stableId(value: unknown, label: string): string {\n  if (typeof value !== \"string\" || !STABLE_ID.test(value) || /^0+$/u.test(value)) {\n    throw new TypeError(`${label} must be nonzero fixed-width lowercase hexadecimal text`);\n  }\n  return value;\n}\n\nfunction replicaIdentity(value: unknown, label: string): string {\n  if (typeof value !== \"string\" || !REPLICA_ID.test(value) || /^0+$/u.test(value)) {\n    throw new TypeError(`${label} must be nonzero 64-bit lowercase hexadecimal text`);\n  }\n  return value;\n}\n\nfunction portableTransactionId(value: unknown, label: string): string {\n  if (typeof value !== \"string\" || !CLIENT_TRANSACTION_ID.test(value)) {\n    throw new TypeError(`${label} must contain 1-200 portable identifier characters`);\n  }\n  return value;\n}\n\nfunction positiveU16(value: unknown, label: string): number {\n  if (!Number.isInteger(value) || (value as number) < 1 || (value as number) > 0xffff) {\n    throw new TypeError(`${label} must be a positive 16-bit integer`);\n  }\n  return value as number;\n}\n\nfunction positiveSafeInteger(value: unknown, label: string): number {\n  if (!Number.isSafeInteger(value) || (value as number) < 1) {\n    throw new TypeError(`${label} must be a positive safe integer`);\n  }\n  return value as number;\n}\n\nfunction nonnegativeSafeInteger(value: unknown, label: string): number {\n  if (!Number.isSafeInteger(value) || (value as number) < 0) {\n    throw new TypeError(`${label} must be a nonnegative safe integer`);\n  }\n  return value as number;\n}\n\nfunction compareCodeUnits(left: string, right: string): number {\n  return left < right ? -1 : left > right ? 1 : 0;\n}\n\nfunction equalBytes(left: Uint8Array, right: Uint8Array): boolean {\n  return (\n    left.byteLength === right.byteLength && left.every((value, index) => value === right[index])\n  );\n}\n\nclass BinaryWriter {\n  private buffer = new Uint8Array(1_024);\n  private length = 0;\n\n  constructor(private readonly maximum: number) {}\n\n  u8(value: number): void {\n    this.ensure(1);\n    this.buffer[this.length++] = value;\n  }\n\n  u16(value: number): void {\n    this.ensure(2);\n    this.buffer[this.length++] = value & 0xff;\n    this.buffer[this.length++] = (value >>> 8) & 0xff;\n  }\n\n  u32(value: number): void {\n    this.ensure(4);\n    for (let offset = 0; offset < 4; offset += 1) {\n      this.buffer[this.length++] = Math.floor(value / 2 ** (offset * 8)) & 0xff;\n    }\n  }\n\n  u64(value: number): void {\n    if (!Number.isSafeInteger(value) || value < 0) throw new TypeError(\"u64 must be safe\");\n    this.ensure(8);\n    let remaining = BigInt(value);\n    for (let offset = 0; offset < 8; offset += 1) {\n      this.buffer[this.length++] = Number(remaining & 0xffn);\n      remaining >>= 8n;\n    }\n  }\n\n  string(value: string): void {\n    const bytes = textEncoder.encode(value);\n    if (bytes.byteLength > 0xffff) throw new RangeError(\"intent string exceeds 65535 bytes\");\n    this.u16(bytes.byteLength);\n    this.bytes(bytes);\n  }\n\n  byteBlock(value: Uint8Array): void {\n    this.u32(value.byteLength);\n    this.bytes(value);\n  }\n\n  bytes(value: Uint8Array): void {\n    this.ensure(value.byteLength);\n    this.buffer.set(value, this.length);\n    this.length += value.byteLength;\n  }\n\n  finish(): Uint8Array {\n    return this.buffer.slice(0, this.length);\n  }\n\n  private ensure(additional: number): void {\n    const needed = this.length + additional;\n    if (!Number.isSafeInteger(needed) || needed > this.maximum) {\n      throw new RangeError(\"editable artifact intent exceeds its byte limit\");\n    }\n    if (needed <= this.buffer.byteLength) return;\n    let size = this.buffer.byteLength;\n    while (size < needed) size = Math.min(this.maximum, size * 2);\n    const next = new Uint8Array(size);\n    next.set(this.buffer.subarray(0, this.length));\n    this.buffer = next;\n  }\n}\n\nclass BinaryReader {\n  private offset = 0;\n\n  constructor(private readonly input: Uint8Array) {}\n\n  u8(): number {\n    this.require(1);\n    return this.input[this.offset++]!;\n  }\n\n  u16(): number {\n    this.require(2);\n    const value = this.input[this.offset]! | (this.input[this.offset + 1]! << 8);\n    this.offset += 2;\n    return value;\n  }\n\n  u32(): number {\n    this.require(4);\n    const value =\n      this.input[this.offset]! +\n      this.input[this.offset + 1]! * 2 ** 8 +\n      this.input[this.offset + 2]! * 2 ** 16 +\n      this.input[this.offset + 3]! * 2 ** 24;\n    this.offset += 4;\n    return value;\n  }\n\n  u64(): number {\n    this.require(8);\n    let value = 0n;\n    for (let offset = 0; offset < 8; offset += 1) {\n      value |= BigInt(this.input[this.offset + offset]!) << BigInt(offset * 8);\n    }\n    this.offset += 8;\n    if (value > BigInt(Number.MAX_SAFE_INTEGER)) throw new RangeError(\"u64 exceeds safe integer\");\n    return Number(value);\n  }\n\n  string(): string {\n    return textDecoder.decode(this.bytes(this.u16()));\n  }\n\n  byteBlock(maximum: number): Uint8Array {\n    const length = this.u32();\n    if (length < 1) throw new TypeError(\"commandBytes must not be empty\");\n    if (length > maximum) throw new RangeError(\"commandBytes exceeds its byte limit\");\n    return this.bytes(length);\n  }\n\n  bytes(length: number): Uint8Array {\n    this.require(length);\n    const output = this.input.subarray(this.offset, this.offset + length);\n    this.offset += length;\n    return output;\n  }\n\n  done(): void {\n    if (this.offset !== this.input.byteLength) {\n      throw new TypeError(\"editable artifact intent contains trailing bytes\");\n    }\n  }\n\n  private require(length: number): void {\n    if (\n      !Number.isSafeInteger(length) ||\n      length < 0 ||\n      this.offset + length > this.input.byteLength\n    ) {\n      throw new TypeError(\"truncated editable artifact intent\");\n    }\n  }\n}\n"],"mappings":"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","names":[]}