@theelena/sdk 0.1.0 → 0.1.1

package/dist/agent.js

@@ -0,0 +1,1786 @@
+// src/agent/index.ts
+import { createHash } from "crypto";
+
+// ../shared/src/agent-contracts/common.ts
+import { z } from "zod";
+var ELENA_AGENT_CONTRACT_VERSION = "1";
+var elenaAgentVersionSchema = z.literal(ELENA_AGENT_CONTRACT_VERSION);
+var elenaAgentIdSchema = z.uuid();
+var elenaAgentRevisionSchema = z.number().int().min(1).max(Number.MAX_SAFE_INTEGER);
+var elenaAgentTimestampSchema = z.iso.datetime();
+var elenaAgentHashSchema = z.string().regex(/^[a-f0-9]{64}$/);
+var elenaAgentRefSchema = z.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9._:-]{0,99}$/);
+var elenaAgentNameSchema = z.string().trim().min(1).max(160);
+var elenaAgentTextSchema = z.string().trim().min(1).max(2e3);
+var elenaAgentCurrencySchema = z.literal("PEN");
+var elenaAgentNonnegativeMoneySchema = z.string().regex(/^(0|[1-9]\d{0,7})\.\d{2}$/);
+var elenaAgentMoneySchema = elenaAgentNonnegativeMoneySchema.refine(
+  (value) => value !== "0.00",
+  "Product price must be greater than zero"
+);
+var ELENA_AGENT_LIMITS = Object.freeze({
+  categoriesPerImport: 50,
+  productsPerImport: 200,
+  changesPerOperation: 200,
+  publicationProducts: 200,
+  galleryImages: 8,
+  extraGroups: 10,
+  optionsPerGroup: 30,
+  jsonBytes: 1024 * 1024,
+  mediaBytes: 10 * 1024 * 1024,
+  stagedBytesPerRestaurant: 100 * 1024 * 1024,
+  stagedFilesPerRestaurant: 20,
+  openOperationsPerRestaurant: 20,
+  openPreviewsPerRestaurant: 20,
+  activeKeysPerFamily: 10,
+  keyDefaultTtlSeconds: 30 * 24 * 60 * 60,
+  keyMaxTtlSeconds: 90 * 24 * 60 * 60,
+  pairingTtlSeconds: 600,
+  pairingPollSeconds: 5,
+  proposalTtlSeconds: 24 * 60 * 60,
+  previewTtlSeconds: 24 * 60 * 60,
+  stagingTtlSeconds: 48 * 60 * 60,
+  applyWindowSeconds: 60 * 60,
+  workerLeaseSeconds: 30,
+  workerHeartbeatSeconds: 10,
+  maxWorkerAttempts: 5,
+  resultRetentionDays: 90,
+  pageSize: 100
+});
+var elenaAgentErrorCodeSchema = z.enum([
+  "INVALID_REQUEST",
+  "UNSUPPORTED_VERSION",
+  "CREDENTIAL_REQUIRED",
+  "CREDENTIAL_INVALID",
+  "CREDENTIAL_EXPIRED",
+  "CREDENTIAL_REVOKED",
+  "CREDENTIAL_MIXED",
+  "CREDENTIAL_WRONG_FAMILY",
+  "OWNER_REQUIRED",
+  "ORIGIN_REJECTED",
+  "APPROVAL_REQUIRED",
+  "APPROVAL_REJECTED",
+  "APPROVAL_EXPIRED",
+  "APPROVAL_MISMATCH",
+  "SCOPE_REQUIRED",
+  "MODE_READ_ONLY",
+  "API_ACCESS_DISABLED",
+  "RESTAURANT_NOT_APPROVED",
+  "NOT_FOUND",
+  "VERSION_CONFLICT",
+  "IDEMPOTENCY_CONFLICT",
+  "INVALID_PRICE",
+  "UNCONFIRMED_DATA",
+  "REFERENCE_CONFLICT",
+  "MEDIA_INVALID",
+  "MEDIA_EXPIRED",
+  "QUOTA_EXCEEDED",
+  "RATE_LIMITED",
+  "PAIRING_PENDING",
+  "PAIRING_DENIED",
+  "PAIRING_EXPIRED",
+  "PAIRING_CONSUMED",
+  "OPERATION_TERMINAL",
+  "APPLY_WINDOW_EXPIRED",
+  "DEPENDENCY_FAILED",
+  "TEMPORARY_UNAVAILABLE",
+  "INTERNAL_ERROR"
+]);
+var elenaAgentErrorSchema = z.strictObject({
+  version: elenaAgentVersionSchema,
+  error: z.strictObject({
+    code: elenaAgentErrorCodeSchema,
+    message: z.string().max(500),
+    retryable: z.boolean(),
+    requestId: elenaAgentRefSchema,
+    retryAfterSeconds: z.number().int().min(1).max(3600).optional(),
+    issues: z.array(
+      z.strictObject({
+        path: z.string().max(200),
+        code: elenaAgentErrorCodeSchema,
+        message: z.string().max(200)
+      })
+    ).max(250).optional()
+  })
+});
+var elenaAgentPageQuerySchema = z.strictObject({
+  version: elenaAgentVersionSchema,
+  cursor: z.string().regex(/^[a-zA-Z0-9_-]{1,512}$/).optional(),
+  limit: z.number().int().min(1).max(ELENA_AGENT_LIMITS.pageSize).default(50)
+});
+var elenaAgentEmptyRequestSchema = z.strictObject({ version: elenaAgentVersionSchema });
+var elenaAgentAckSchema = z.strictObject({
+  version: elenaAgentVersionSchema,
+  ok: z.literal(true)
+});
+
+// ../shared/src/agent-contracts/access.ts
+import { z as z2 } from "zod";
+var ELENA_AGENT_TRANSPORT = Object.freeze({
+  agentPrefix: "elena_sk_",
+  agentHeader: "x-elena-agent-key",
+  agentPath: "/api/v1/agent",
+  clientPrefix: "elena_pk_",
+  clientHeader: "x-elena-client-key",
+  clientPath: "/api/v1/public/sdk",
+  ownerPath: "/api/v1/agent-access"
+});
+var elenaAgentSecretSchema = z2.string().regex(/^elena_sk_[A-Za-z0-9_-]{43}$/);
+var elenaManualClientKeySchema = z2.string().regex(/^elena_pk_[A-Za-z0-9_-]{43}$/);
+var elenaManagedClientKeySchema = z2.string().max(160).regex(
+  /^elena_pk_m_[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}\.[1-9]\d{0,15}\.[A-Za-z0-9_-]{43}$/
+);
+var elenaClientKeySchema = z2.union([
+  elenaManualClientKeySchema,
+  elenaManagedClientKeySchema
+]);
+var elenaAgentDeviceCodeSchema = z2.string().regex(/^[A-Za-z0-9_-]{43}$/);
+var elenaAgentUserCodeSchema = z2.string().regex(/^[A-HJ-NP-Z2-9]{4}-[A-HJ-NP-Z2-9]{4}$/);
+var elenaAgentModeSchema = z2.enum(["read", "mutate"]);
+var elenaAgentScopeSchema = z2.enum([
+  "catalog:read",
+  "catalog:write",
+  "catalog:publish",
+  "assets:read",
+  "assets:write"
+]);
+var elenaAgentScopesSchema = z2.array(elenaAgentScopeSchema).min(1).max(5).refine((scopes) => new Set(scopes).size === scopes.length, "Duplicate scope").refine((scopes) => scopes.includes("catalog:read"), "catalog:read is mandatory");
+var elenaAgentActionSchema = z2.enum([
+  "context.read",
+  "catalog.read",
+  "assets.read",
+  "assets.stage",
+  "operations.read",
+  "operations.propose",
+  "operations.apply",
+  "catalog.publish"
+]);
+var elenaAgentRestaurantSchema = z2.strictObject({
+  id: elenaAgentIdSchema,
+  name: elenaAgentNameSchema,
+  slug: z2.string().regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/).max(100),
+  currency: elenaAgentCurrencySchema
+});
+var keyTtl = z2.number().int().min(3600).max(ELENA_AGENT_LIMITS.keyMaxTtlSeconds).default(ELENA_AGENT_LIMITS.keyDefaultTtlSeconds);
+var elenaAgentKeyCreateRequestSchema = z2.discriminatedUnion("kind", [
+  z2.strictObject({
+    version: elenaAgentVersionSchema,
+    kind: z2.literal("agent"),
+    label: elenaAgentNameSchema,
+    mode: elenaAgentModeSchema.default("read"),
+    scopes: elenaAgentScopesSchema.default(["catalog:read", "assets:read"]),
+    ttlSeconds: keyTtl
+  }),
+  z2.strictObject({
+    version: elenaAgentVersionSchema,
+    kind: z2.literal("client"),
+    label: elenaAgentNameSchema,
+    ttlSeconds: keyTtl
+  })
+]);
+var elenaAgentKeyPolicyRequestSchema = z2.strictObject({
+  version: elenaAgentVersionSchema,
+  expectedRevision: elenaAgentRevisionSchema,
+  mode: elenaAgentModeSchema,
+  scopes: elenaAgentScopesSchema
+});
+var elenaAgentKeyRevokeRequestSchema = z2.strictObject({
+  version: elenaAgentVersionSchema,
+  expectedRevision: elenaAgentRevisionSchema
+});
+var elenaAgentKeyReplaceRequestSchema = z2.strictObject({
+  version: elenaAgentVersionSchema,
+  expectedRevision: elenaAgentRevisionSchema,
+  ttlSeconds: keyTtl
+});
+var keyMetadata = {
+  id: elenaAgentIdSchema,
+  label: elenaAgentNameSchema,
+  displaySuffix: z2.string().regex(/^[A-Za-z0-9_-]{6}$/),
+  revision: elenaAgentRevisionSchema,
+  status: z2.enum(["active", "revoked", "expired"]),
+  createdAt: elenaAgentTimestampSchema,
+  expiresAt: elenaAgentTimestampSchema,
+  revokedAt: elenaAgentTimestampSchema.nullable(),
+  lastUsedAt: elenaAgentTimestampSchema.nullable()
+};
+var elenaAgentKeyMetadataSchema = z2.discriminatedUnion("kind", [
+  z2.strictObject({
+    ...keyMetadata,
+    kind: z2.literal("agent"),
+    mode: elenaAgentModeSchema,
+    scopes: elenaAgentScopesSchema
+  }),
+  z2.strictObject({ ...keyMetadata, kind: z2.literal("client") })
+]);
+var elenaAgentKeyListSchema = z2.strictObject({
+  version: elenaAgentVersionSchema,
+  keys: z2.array(elenaAgentKeyMetadataSchema).max(20)
+});
+var elenaAgentKeyReceiptSchema = z2.discriminatedUnion("kind", [
+  z2.strictObject({
+    version: elenaAgentVersionSchema,
+    kind: z2.literal("agent"),
+    key: elenaAgentKeyMetadataSchema.options[0],
+    secret: elenaAgentSecretSchema
+  }),
+  z2.strictObject({
+    version: elenaAgentVersionSchema,
+    kind: z2.literal("client"),
+    key: elenaAgentKeyMetadataSchema.options[1],
+    clientKey: elenaManualClientKeySchema
+  })
+]);
+var elenaAgentKeyResponseSchema = z2.strictObject({
+  version: elenaAgentVersionSchema,
+  key: elenaAgentKeyMetadataSchema
+});
+var elenaAgentHttpsUrlSchema = z2.url({ protocol: /^https$/ }).max(2048).refine(
+  (value) => /^https:\/\/[^/?#@\\\s]+(?:[/?#]|$)/.test(value),
+  "URL must not contain userinfo"
+);
+var elenaAgentConnectionUrlSchema = z2.url({ protocol: /^https?$/ }).max(2048).refine(
+  (value) => /^https?:\/\/[^/?#@\\\s]+(?:[/?#]|$)/.test(value),
+  "URL must not contain userinfo"
+);
+var elenaAgentBaseUrlSchema = elenaAgentHttpsUrlSchema.refine(
+  (value) => /^https:\/\/[^/?#@\\\s]+\/?$/.test(value),
+  "Base URL must be an explicit origin"
+);
+var elenaAgentConnectionOriginSchema = elenaAgentConnectionUrlSchema.refine(
+  (value) => /^https?:\/\/[^/?#@\\\s]+\/?$/.test(value),
+  "Base URL must be an explicit origin"
+);
+var elenaAgentPairingStartRequestSchema = z2.strictObject({
+  version: elenaAgentVersionSchema,
+  label: elenaAgentNameSchema
+});
+var elenaAgentPairingStartResponseSchema = z2.strictObject({
+  version: elenaAgentVersionSchema,
+  pairingId: elenaAgentIdSchema,
+  deviceCode: elenaAgentDeviceCodeSchema,
+  userCode: elenaAgentUserCodeSchema,
+  verificationUrl: elenaAgentConnectionUrlSchema,
+  expiresAt: elenaAgentTimestampSchema,
+  intervalSeconds: z2.literal(ELENA_AGENT_LIMITS.pairingPollSeconds)
+});
+var elenaAgentPairingPollRequestSchema = z2.strictObject({
+  version: elenaAgentVersionSchema,
+  deviceCode: elenaAgentDeviceCodeSchema
+});
+var elenaAgentPairingReviewSchema = z2.strictObject({
+  version: elenaAgentVersionSchema,
+  label: elenaAgentNameSchema,
+  userCode: elenaAgentUserCodeSchema,
+  state: z2.enum(["pending", "approved", "rejected", "expired", "consumed"]),
+  expiresAt: elenaAgentTimestampSchema
+});
+var elenaAgentPairingDecisionRequestSchema = z2.discriminatedUnion("decision", [
+  z2.strictObject({
+    version: elenaAgentVersionSchema,
+    userCode: elenaAgentUserCodeSchema,
+    decision: z2.literal("approve"),
+    mode: elenaAgentModeSchema.default("read"),
+    scopes: elenaAgentScopesSchema.default(["catalog:read", "assets:read"]),
+    ttlSeconds: keyTtl
+  }),
+  z2.strictObject({
+    version: elenaAgentVersionSchema,
+    userCode: elenaAgentUserCodeSchema,
+    decision: z2.literal("reject")
+  })
+]);
+var elenaAgentPairingPollResponseSchema = z2.discriminatedUnion("status", [
+  z2.strictObject({
+    version: elenaAgentVersionSchema,
+    status: z2.literal("pending"),
+    expiresAt: elenaAgentTimestampSchema,
+    intervalSeconds: z2.literal(ELENA_AGENT_LIMITS.pairingPollSeconds)
+  }),
+  z2.strictObject({
+    version: elenaAgentVersionSchema,
+    status: z2.literal("delivered"),
+    restaurant: elenaAgentRestaurantSchema,
+    credential: elenaAgentKeyReceiptSchema.options[0]
+  })
+]);
+var elenaAgentContextSchema = z2.strictObject({
+  version: elenaAgentVersionSchema,
+  restaurant: elenaAgentRestaurantSchema,
+  principal: z2.strictObject({
+    kind: z2.literal("agent"),
+    credentialId: elenaAgentIdSchema,
+    credentialRevision: elenaAgentRevisionSchema,
+    mode: elenaAgentModeSchema,
+    scopes: elenaAgentScopesSchema,
+    expiresAt: elenaAgentTimestampSchema
+  }),
+  capabilities: z2.strictObject({
+    apiAccess: z2.literal(true),
+    menu: z2.literal(true),
+    imports: z2.boolean(),
+    media: z2.boolean(),
+    publication: z2.boolean()
+  }),
+  actions: z2.array(elenaAgentActionSchema).min(1).max(8).refine((actions) => new Set(actions).size === actions.length, "Duplicate action")
+}).superRefine((value, ctx) => {
+  const requiredScopes = {
+    "catalog.read": "catalog:read",
+    "assets.read": "assets:read",
+    "assets.stage": "assets:write",
+    "operations.propose": "catalog:write",
+    "operations.apply": "catalog:write",
+    "catalog.publish": "catalog:publish"
+  };
+  const writes = {
+    "assets.stage": true,
+    "operations.propose": true,
+    "operations.apply": true,
+    "catalog.publish": true
+  };
+  for (const action of value.actions) {
+    if (value.principal.mode === "read" && writes[action]) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["actions"],
+        message: "Read mode cannot expose mutation actions"
+      });
+    }
+    const scope = requiredScopes[action];
+    if (scope && !value.principal.scopes.includes(scope)) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["actions"],
+        message: "Action exceeds granted scopes"
+      });
+    }
+  }
+  if (value.actions.includes("catalog.publish") && !value.principal.scopes.includes("catalog:write")) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["actions"],
+      message: "Publication also requires catalog:write"
+    });
+  }
+  const expectedCapabilities = {
+    imports: value.actions.includes("operations.propose") && value.actions.includes("operations.apply"),
+    media: value.actions.includes("assets.stage"),
+    publication: value.actions.includes("catalog.publish")
+  };
+  for (const capability of ["imports", "media", "publication"]) {
+    if (value.capabilities[capability] !== expectedCapabilities[capability]) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["capabilities", capability],
+        message: "Capability must match effective actions"
+      });
+    }
+  }
+});
+var elenaClientContextSchema = z2.strictObject({
+  version: elenaAgentVersionSchema,
+  restaurant: elenaAgentRestaurantSchema,
+  capabilities: z2.strictObject({ menu: z2.literal(true), assets: z2.literal(true) })
+});
+var elenaAgentCliAuthStatusSchema = z2.strictObject({
+  version: elenaAgentVersionSchema,
+  authenticated: z2.boolean(),
+  source: z2.enum(["store", "environment", "none"]),
+  baseUrl: elenaAgentBaseUrlSchema.nullable(),
+  credentialId: elenaAgentIdSchema.nullable(),
+  restaurantId: elenaAgentIdSchema.nullable(),
+  expiresAt: elenaAgentTimestampSchema.nullable()
+});
+var elenaAgentCliLogoutSchema = z2.strictObject({
+  version: elenaAgentVersionSchema,
+  loggedOut: z2.literal(true),
+  remoteRevoked: z2.literal(false),
+  environmentCredentialPresent: z2.boolean()
+});
+
+// ../shared/src/agent-contracts/catalog.ts
+import { z as z3 } from "zod";
+var elenaAgentExistingTargetSchema = z3.strictObject({
+  kind: z3.literal("id"),
+  id: elenaAgentIdSchema,
+  expectedVersion: elenaAgentRevisionSchema
+});
+var elenaAgentExternalTargetSchema = z3.strictObject({
+  kind: z3.literal("external"),
+  namespace: elenaAgentRefSchema,
+  key: elenaAgentRefSchema,
+  expectedVersion: elenaAgentRevisionSchema.nullable()
+});
+var elenaAgentTargetSchema = z3.discriminatedUnion("kind", [
+  elenaAgentExistingTargetSchema,
+  elenaAgentExternalTargetSchema
+]);
+var elenaAgentCategoryReferenceSchema = z3.discriminatedUnion("kind", [
+  elenaAgentExistingTargetSchema,
+  z3.strictObject({ kind: z3.literal("ref"), ref: elenaAgentRefSchema })
+]);
+var elenaAgentDescriptionSchema = z3.discriminatedUnion("status", [
+  z3.strictObject({ status: z3.literal("transcribed"), text: elenaAgentTextSchema }),
+  z3.strictObject({ status: z3.literal("proposed"), text: elenaAgentTextSchema })
+]);
+var elenaAgentConfirmedPriceSchema = z3.strictObject({
+  status: z3.literal("confirmed"),
+  amount: elenaAgentMoneySchema,
+  basis: z3.literal("operator")
+});
+var elenaAgentDraftPriceSchema = z3.discriminatedUnion("status", [
+  elenaAgentConfirmedPriceSchema,
+  z3.strictObject({
+    status: z3.literal("unconfirmed"),
+    reason: z3.enum(["missing", "illegible"]),
+    rawText: z3.string().max(100).nullable()
+  })
+]);
+var elenaAgentMediaReferenceSchema = z3.discriminatedUnion("kind", [
+  z3.strictObject({
+    kind: z3.literal("existing"),
+    assetId: elenaAgentIdSchema,
+    sha256: elenaAgentHashSchema
+  }),
+  z3.strictObject({
+    kind: z3.literal("staged"),
+    stagingId: elenaAgentIdSchema,
+    sha256: elenaAgentHashSchema
+  })
+]);
+var elenaAgentGallerySchema = z3.array(elenaAgentMediaReferenceSchema).max(ELENA_AGENT_LIMITS.galleryImages).refine(
+  (images) => new Set(images.map((image) => image.kind === "existing" ? image.assetId : image.stagingId)).size === images.length,
+  "Duplicate media reference"
+);
+var elenaAgentExtraOptionSchema = z3.strictObject({
+  name: elenaAgentNameSchema,
+  additionalPrice: elenaAgentNonnegativeMoneySchema,
+  order: z3.number().int().min(0).max(1e3)
+});
+var elenaAgentExtraGroupSchema = z3.strictObject({
+  name: elenaAgentNameSchema,
+  required: z3.boolean(),
+  minSelections: z3.number().int().min(0).max(ELENA_AGENT_LIMITS.optionsPerGroup),
+  maxSelections: z3.number().int().min(1).max(ELENA_AGENT_LIMITS.optionsPerGroup),
+  order: z3.number().int().min(0).max(1e3),
+  options: z3.array(elenaAgentExtraOptionSchema).min(1).max(ELENA_AGENT_LIMITS.optionsPerGroup)
+}).superRefine((group, ctx) => {
+  if (group.minSelections > group.maxSelections || group.maxSelections > group.options.length) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["maxSelections"],
+      message: "Invalid selection bounds"
+    });
+  }
+  if (group.required && group.minSelections < 1 || !group.required && group.minSelections !== 0) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["minSelections"],
+      message: "Required must match minimum selection count"
+    });
+  }
+  if (new Set(
+    group.options.map((option) => option.name.normalize("NFKC").trim().toLocaleLowerCase("es"))
+  ).size !== group.options.length) {
+    ctx.addIssue({ code: "custom", path: ["options"], message: "Duplicate option name" });
+  }
+});
+var elenaAgentExtrasSchema = z3.strictObject({
+  confirmed: z3.literal(true),
+  groups: z3.array(elenaAgentExtraGroupSchema).max(ELENA_AGENT_LIMITS.extraGroups)
+}).refine(
+  (extras) => new Set(
+    extras.groups.map((group) => group.name.normalize("NFKC").trim().toLocaleLowerCase("es"))
+  ).size === extras.groups.length,
+  "Duplicate group name"
+);
+var elenaAgentCategoryDataSchema = z3.strictObject({
+  name: elenaAgentNameSchema,
+  description: elenaAgentDescriptionSchema.nullable(),
+  order: z3.number().int().min(0).max(1e4)
+});
+var productFields = {
+  type: z3.literal("menu"),
+  name: elenaAgentNameSchema,
+  description: elenaAgentDescriptionSchema.nullable(),
+  category: elenaAgentCategoryReferenceSchema,
+  available: z3.boolean(),
+  images: elenaAgentGallerySchema,
+  extras: elenaAgentExtrasSchema
+};
+var elenaAgentProductDataSchema = z3.strictObject({
+  ...productFields,
+  price: elenaAgentConfirmedPriceSchema
+});
+var elenaAgentDraftProductDataSchema = z3.strictObject({
+  ...productFields,
+  price: elenaAgentDraftPriceSchema
+});
+var elenaAgentCategoryChangeSchema = z3.strictObject({
+  kind: z3.literal("category.upsert"),
+  ref: elenaAgentRefSchema,
+  target: elenaAgentTargetSchema,
+  data: elenaAgentCategoryDataSchema
+});
+var elenaAgentProductChangeSchema = z3.strictObject({
+  kind: z3.literal("product.upsert"),
+  ref: elenaAgentRefSchema,
+  target: elenaAgentTargetSchema,
+  data: elenaAgentProductDataSchema
+});
+var elenaAgentChangeSchema = z3.discriminatedUnion("kind", [
+  elenaAgentCategoryChangeSchema,
+  elenaAgentProductChangeSchema
+]);
+var elenaAgentCategorySchema = z3.strictObject({
+  id: elenaAgentIdSchema,
+  revision: elenaAgentRevisionSchema,
+  name: elenaAgentNameSchema,
+  description: elenaAgentTextSchema.nullable(),
+  order: z3.number().int().min(0).max(1e4)
+});
+var elenaAgentProductSchema = z3.strictObject({
+  id: elenaAgentIdSchema,
+  revision: elenaAgentRevisionSchema,
+  type: z3.literal("menu"),
+  name: elenaAgentNameSchema,
+  basePrice: elenaAgentMoneySchema,
+  description: elenaAgentTextSchema.nullable(),
+  categoryId: elenaAgentIdSchema,
+  available: z3.boolean(),
+  publishedToMenu: z3.boolean(),
+  isDraft: z3.boolean(),
+  images: z3.array(z3.strictObject({ assetId: elenaAgentIdSchema, sha256: elenaAgentHashSchema })).max(ELENA_AGENT_LIMITS.galleryImages),
+  /** Present on current native reads; optional only for retained v1 snapshots. */
+  primaryImageId: elenaAgentIdSchema.nullable().optional(),
+  extraGroups: z3.array(elenaAgentExtraGroupSchema).max(ELENA_AGENT_LIMITS.extraGroups)
+});
+var elenaAgentCategoryListSchema = z3.strictObject({
+  version: elenaAgentVersionSchema,
+  categories: z3.array(elenaAgentCategorySchema).max(ELENA_AGENT_LIMITS.pageSize),
+  nextCursor: z3.string().regex(/^[a-zA-Z0-9_-]{1,512}$/).nullable()
+});
+var elenaAgentProductListSchema = z3.strictObject({
+  version: elenaAgentVersionSchema,
+  products: z3.array(elenaAgentProductSchema).max(ELENA_AGENT_LIMITS.pageSize),
+  nextCursor: z3.string().regex(/^[a-zA-Z0-9_-]{1,512}$/).nullable()
+});
+var elenaAgentProductResponseSchema = z3.strictObject({
+  version: elenaAgentVersionSchema,
+  product: elenaAgentProductSchema,
+  /** Authoritative editing metadata; never infer primary image from gallery order. */
+  editable: z3.strictObject({
+    restaurantId: elenaAgentIdSchema,
+    productId: elenaAgentIdSchema,
+    imageId: elenaAgentIdSchema.nullable(),
+    categoryRevision: elenaAgentRevisionSchema,
+    primaryImage: z3.strictObject({ assetId: elenaAgentIdSchema, sha256: elenaAgentHashSchema }).nullable().optional(),
+    imageEditorUrl: elenaAgentHttpsUrlSchema.optional()
+  }).optional()
+});
+var elenaAgentCategoryResponseSchema = z3.strictObject({
+  version: elenaAgentVersionSchema,
+  category: elenaAgentCategorySchema
+});
+var elenaAgentMediaStageRequestSchema = z3.strictObject({
+  version: elenaAgentVersionSchema,
+  idempotencyKey: elenaAgentRefSchema,
+  fileName: z3.string().regex(/^[a-zA-Z0-9][a-zA-Z0-9._-]{0,119}\.(?:jpg|jpeg|png|webp)$/),
+  mimeType: z3.enum(["image/jpeg", "image/png", "image/webp"]),
+  bytes: z3.number().int().min(1).max(ELENA_AGENT_LIMITS.mediaBytes),
+  sha256: elenaAgentHashSchema
+});
+var elenaAgentMediaStagedSchema = z3.strictObject({
+  version: elenaAgentVersionSchema,
+  stagingId: elenaAgentIdSchema,
+  sha256: elenaAgentHashSchema,
+  mimeType: z3.enum(["image/jpeg", "image/png", "image/webp"]),
+  bytes: z3.number().int().min(1).max(ELENA_AGENT_LIMITS.mediaBytes),
+  expiresAt: elenaAgentTimestampSchema
+});
+var elenaAgentAssetSchema = z3.strictObject({
+  version: elenaAgentVersionSchema,
+  assetId: elenaAgentIdSchema,
+  sha256: elenaAgentHashSchema,
+  mimeType: z3.enum(["image/jpeg", "image/png", "image/webp"]),
+  bytes: z3.number().int().min(1).max(ELENA_AGENT_LIMITS.mediaBytes)
+});
+var elenaClientAssetSchema = z3.strictObject({
+  assetId: elenaAgentIdSchema,
+  url: elenaAgentHttpsUrlSchema
+});
+var elenaClientCategorySchema = z3.strictObject({
+  id: elenaAgentIdSchema,
+  name: elenaAgentNameSchema,
+  description: elenaAgentTextSchema.nullable(),
+  order: z3.number().int().min(0).max(1e4)
+});
+var elenaClientProductSchema = z3.strictObject({
+  id: elenaAgentIdSchema,
+  type: z3.literal("menu"),
+  name: elenaAgentNameSchema,
+  basePrice: elenaAgentMoneySchema,
+  description: elenaAgentTextSchema.nullable(),
+  categoryId: elenaAgentIdSchema,
+  available: z3.boolean(),
+  images: z3.array(elenaClientAssetSchema).max(ELENA_AGENT_LIMITS.galleryImages),
+  extraGroups: z3.array(elenaAgentExtraGroupSchema).max(ELENA_AGENT_LIMITS.extraGroups)
+});
+var elenaClientCatalogSchema = z3.strictObject({
+  version: elenaAgentVersionSchema,
+  categories: z3.array(elenaClientCategorySchema).max(ELENA_AGENT_LIMITS.pageSize),
+  products: z3.array(elenaClientProductSchema).max(ELENA_AGENT_LIMITS.pageSize),
+  nextCursor: z3.string().regex(/^[a-zA-Z0-9_-]{1,512}$/).nullable()
+});
+var elenaClientProductResponseSchema = z3.strictObject({
+  version: elenaAgentVersionSchema,
+  product: elenaClientProductSchema
+});
+var elenaClientAssetResponseSchema = z3.strictObject({
+  version: elenaAgentVersionSchema,
+  asset: elenaClientAssetSchema
+});
+
+// ../shared/src/agent-contracts/operations.ts
+import { z as z4 } from "zod";
+function normalizedValuesEqual(left, right) {
+  if (left === right) return true;
+  if (Array.isArray(left) || Array.isArray(right)) {
+    return Array.isArray(left) && Array.isArray(right) && left.length === right.length && left.every((value, index) => normalizedValuesEqual(value, right[index]));
+  }
+  if (left === null || right === null || typeof left !== "object" || typeof right !== "object") {
+    return false;
+  }
+  const leftRecord = left;
+  const rightRecord = right;
+  const keys = Object.keys(leftRecord);
+  return keys.length === Object.keys(rightRecord).length && keys.every(
+    (key) => Object.prototype.hasOwnProperty.call(rightRecord, key) && normalizedValuesEqual(leftRecord[key], rightRecord[key])
+  );
+}
+var elenaAgentChangesSchema = z4.array(elenaAgentChangeSchema).min(1).max(ELENA_AGENT_LIMITS.changesPerOperation).superRefine((changes, ctx) => {
+  const refs = /* @__PURE__ */ new Set();
+  const targets = /* @__PURE__ */ new Set();
+  const categoryRefs = new Set(
+    changes.filter((change) => change.kind === "category.upsert").map((change) => change.ref)
+  );
+  changes.forEach((change, index) => {
+    const target = change.target.kind === "id" ? `${change.kind}:id:${change.target.id}` : JSON.stringify([change.kind, "external", change.target.namespace, change.target.key]);
+    if (refs.has(change.ref) || targets.has(target)) {
+      ctx.addIssue({ code: "custom", path: [index], message: "Duplicate ref or target" });
+    }
+    refs.add(change.ref);
+    targets.add(target);
+    if (change.kind === "product.upsert" && change.data.category.kind === "ref" && !categoryRefs.has(change.data.category.ref)) {
+      ctx.addIssue({
+        code: "custom",
+        path: [index, "data", "category"],
+        message: "Unknown category ref"
+      });
+    }
+  });
+});
+var elenaAgentPublicationPayloadSchema = z4.strictObject({
+  kind: z4.literal("publication"),
+  published: z4.boolean(),
+  products: z4.array(elenaAgentExistingTargetSchema).min(1).max(ELENA_AGENT_LIMITS.publicationProducts).refine(
+    (products) => new Set(products.map((product) => product.id)).size === products.length,
+    "Duplicate product"
+  )
+});
+var elenaAgentOperationPayloadSchema = z4.discriminatedUnion("kind", [
+  z4.strictObject({ kind: z4.literal("catalog"), changes: elenaAgentChangesSchema }),
+  elenaAgentPublicationPayloadSchema,
+  z4.strictObject({
+    kind: z4.literal("import"),
+    importId: elenaAgentIdSchema,
+    planHash: elenaAgentHashSchema,
+    selectedRefs: z4.array(elenaAgentRefSchema).min(1).max(ELENA_AGENT_LIMITS.productsPerImport + ELENA_AGENT_LIMITS.categoriesPerImport).refine((refs) => new Set(refs).size === refs.length, "Duplicate selected ref")
+  })
+]);
+var elenaAgentProposalRequestSchema = z4.strictObject({
+  version: elenaAgentVersionSchema,
+  idempotencyKey: elenaAgentRefSchema,
+  payload: elenaAgentOperationPayloadSchema
+});
+var elenaAgentApplyRequestSchema = z4.strictObject({
+  version: elenaAgentVersionSchema,
+  expectedRevision: elenaAgentRevisionSchema,
+  payloadHash: elenaAgentHashSchema
+});
+var elenaAgentApprovalRequestSchema = z4.strictObject({
+  version: elenaAgentVersionSchema,
+  expectedRevision: elenaAgentRevisionSchema,
+  payloadHash: elenaAgentHashSchema,
+  decision: z4.enum(["approve", "reject"])
+});
+var elenaAgentBaseVersionSchema = z4.strictObject({
+  kind: z4.enum(["category", "product", "credential"]),
+  id: elenaAgentIdSchema,
+  revision: elenaAgentRevisionSchema
+});
+var elenaAgentDiffSchema = z4.discriminatedUnion("kind", [
+  z4.strictObject({
+    kind: z4.literal("category"),
+    ref: elenaAgentRefSchema,
+    before: elenaAgentCategorySchema.nullable(),
+    after: elenaAgentCategoryChangeSchema,
+    publicEffect: z4.enum(["none", "immediate_on_apply"])
+  }),
+  z4.strictObject({
+    kind: z4.literal("product"),
+    ref: elenaAgentRefSchema,
+    before: elenaAgentProductSchema.nullable(),
+    after: elenaAgentChangeSchema.options[1],
+    publicEffect: z4.enum(["none", "immediate_on_apply"])
+  }),
+  z4.strictObject({
+    kind: z4.literal("publication"),
+    ref: elenaAgentRefSchema,
+    productId: elenaAgentIdSchema,
+    before: z4.boolean(),
+    after: z4.boolean(),
+    publicEffect: z4.literal("immediate_on_apply")
+  })
+]).superRefine((diff, ctx) => {
+  if (diff.kind === "publication") {
+    if (diff.ref !== `product:${diff.productId}`) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["ref"],
+        message: "Publication ref must identify the exact product"
+      });
+    }
+    return;
+  }
+  if (diff.ref !== diff.after.ref) {
+    ctx.addIssue({ code: "custom", path: ["ref"], message: "Diff must identify its change" });
+  }
+  if (diff.kind === "product") {
+    const effect = diff.before?.publishedToMenu ? "immediate_on_apply" : "none";
+    if (diff.publicEffect !== effect) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["publicEffect"],
+        message: "Diff must disclose current public visibility"
+      });
+    }
+  }
+});
+var elenaAgentItemErrorSchema = z4.strictObject({
+  code: elenaAgentErrorCodeSchema,
+  message: z4.string().max(500),
+  retryable: z4.boolean()
+});
+var elenaAgentResultItemSchema = z4.discriminatedUnion("status", [
+  z4.strictObject({
+    ref: elenaAgentRefSchema,
+    status: z4.literal("applied"),
+    resource: z4.strictObject({
+      kind: z4.enum(["category", "product"]),
+      id: elenaAgentIdSchema,
+      revision: elenaAgentRevisionSchema
+    })
+  }),
+  z4.strictObject({
+    ref: elenaAgentRefSchema,
+    status: z4.literal("skipped"),
+    resource: z4.strictObject({
+      kind: z4.enum(["category", "product"]),
+      id: elenaAgentIdSchema,
+      revision: elenaAgentRevisionSchema
+    })
+  }),
+  z4.strictObject({
+    ref: elenaAgentRefSchema,
+    status: z4.literal("failed"),
+    error: elenaAgentItemErrorSchema
+  }),
+  z4.strictObject({
+    ref: elenaAgentRefSchema,
+    status: z4.literal("blocked"),
+    error: elenaAgentItemErrorSchema
+  })
+]);
+var elenaAgentOperationResultSchema = z4.strictObject({
+  completedAt: elenaAgentTimestampSchema,
+  items: z4.array(elenaAgentResultItemSchema).min(1).max(250)
+}).refine(
+  (result) => new Set(result.items.map((item) => item.ref)).size === result.items.length,
+  "Duplicate result ref"
+);
+var elenaAgentOperationStateSchema = z4.enum([
+  "pending",
+  "approved",
+  "rejected",
+  "expired",
+  "applying",
+  "applied",
+  "partial",
+  "failed",
+  "cancelled"
+]);
+var elenaAgentOperationSchema = z4.strictObject({
+  version: elenaAgentVersionSchema,
+  operationId: elenaAgentIdSchema,
+  revision: elenaAgentRevisionSchema,
+  state: elenaAgentOperationStateSchema,
+  restaurantId: elenaAgentIdSchema,
+  credentialId: elenaAgentIdSchema,
+  credentialRevision: elenaAgentRevisionSchema,
+  payload: elenaAgentOperationPayloadSchema,
+  payloadHash: elenaAgentHashSchema,
+  baseVersions: z4.array(elenaAgentBaseVersionSchema).max(501),
+  diff: z4.array(elenaAgentDiffSchema).max(250),
+  approvalUrl: elenaAgentConnectionUrlSchema,
+  createdAt: elenaAgentTimestampSchema,
+  expiresAt: elenaAgentTimestampSchema,
+  decision: z4.strictObject({
+    outcome: z4.enum(["approved", "rejected"]),
+    decidedAt: elenaAgentTimestampSchema,
+    approverId: elenaAgentIdSchema,
+    payloadHash: elenaAgentHashSchema
+  }).nullable(),
+  applyDeadline: elenaAgentTimestampSchema.nullable(),
+  result: elenaAgentOperationResultSchema.nullable()
+}).superRefine((operation, ctx) => {
+  const approvedRefs = operation.payload.kind === "catalog" ? operation.payload.changes.map((change) => change.ref) : operation.payload.kind === "import" ? operation.payload.selectedRefs : operation.payload.products.map((product) => `product:${product.id}`);
+  if (operation.diff.some((diff) => !approvedRefs.includes(diff.ref)) || new Set(operation.diff.map((diff) => diff.ref)).size !== operation.diff.length) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["diff"],
+      message: "Diff must be a unique subset of the exact approved selection"
+    });
+  }
+  const payload = operation.payload;
+  if (payload.kind === "catalog") {
+    const changes = new Map(payload.changes.map((change) => [change.ref, change]));
+    operation.diff.forEach((diff, index) => {
+      const change = changes.get(diff.ref);
+      if (!change || `${diff.kind}.upsert` !== change.kind || !normalizedValuesEqual(diff.after, change)) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["diff", index],
+          message: "Catalog diff must match the exact normalized payload change"
+        });
+      }
+    });
+  } else if (payload.kind === "publication") {
+    const productIds = new Set(payload.products.map((product) => product.id));
+    operation.diff.forEach((diff, index) => {
+      if (diff.kind !== "publication" || !productIds.has(diff.productId) || diff.after !== payload.published) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["diff", index],
+          message: "Publication diff must match the exact selected product and publication value"
+        });
+      }
+    });
+  }
+  const finished = ["applied", "partial", "failed", "cancelled"].includes(operation.state);
+  if (finished !== (operation.result !== null)) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["result"],
+      message: "Only executed terminal states carry a complete result"
+    });
+  }
+  if (["approved", "applying", "applied", "partial", "failed"].includes(operation.state) && operation.decision?.outcome !== "approved") {
+    ctx.addIssue({
+      code: "custom",
+      path: ["decision"],
+      message: "State requires owner approval"
+    });
+  }
+  if (operation.state === "rejected" && operation.decision?.outcome !== "rejected") {
+    ctx.addIssue({
+      code: "custom",
+      path: ["decision"],
+      message: "Rejected state requires owner rejection"
+    });
+  }
+  if (operation.state === "pending" && operation.decision !== null) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["decision"],
+      message: "Pending operation cannot have a decision"
+    });
+  }
+  if (operation.decision && operation.decision.payloadHash !== operation.payloadHash) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["decision", "payloadHash"],
+      message: "Decision does not bind payload"
+    });
+  }
+  if (operation.state === "applying" && operation.applyDeadline === null) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["applyDeadline"],
+      message: "Applying requires a deadline"
+    });
+  }
+  if (operation.result) {
+    if (operation.result.items.length !== approvedRefs.length || operation.result.items.some((item) => !approvedRefs.includes(item.ref))) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["result"],
+        message: "Result must account for the exact approved selection"
+      });
+    }
+    const success = operation.result.items.some(
+      (item) => item.status === "applied" || item.status === "skipped"
+    );
+    const failure = operation.result.items.some(
+      (item) => item.status === "failed" || item.status === "blocked"
+    );
+    if (operation.state === "applied" && failure || operation.state === "partial" && (!success || !failure) || ["failed", "cancelled"].includes(operation.state) && success) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["result"],
+        message: "Terminal state must describe actual effects"
+      });
+    }
+  }
+});
+var elenaAgentOperationListSchema = z4.strictObject({
+  version: elenaAgentVersionSchema,
+  operations: z4.array(elenaAgentOperationSchema).max(ELENA_AGENT_LIMITS.pageSize),
+  nextCursor: z4.string().regex(/^[a-zA-Z0-9_-]{1,512}$/).nullable()
+});
+var elenaAgentImportSourceSchema = z4.strictObject({
+  kind: z4.enum(["image", "pdf", "table", "manual"]),
+  label: elenaAgentNameSchema,
+  sha256: elenaAgentHashSchema.optional()
+});
+var elenaAgentImportItemSchema = z4.strictObject({
+  ref: elenaAgentRefSchema,
+  target: elenaAgentTargetSchema,
+  data: elenaAgentDraftProductDataSchema
+});
+var elenaAgentImportPreviewRequestSchema = z4.strictObject({
+  version: elenaAgentVersionSchema,
+  idempotencyKey: elenaAgentRefSchema,
+  currency: elenaAgentCurrencySchema,
+  source: elenaAgentImportSourceSchema,
+  categories: z4.array(elenaAgentCategoryChangeSchema).max(ELENA_AGENT_LIMITS.categoriesPerImport),
+  items: z4.array(elenaAgentImportItemSchema).min(1).max(ELENA_AGENT_LIMITS.productsPerImport)
+}).superRefine((request, ctx) => {
+  const refs = /* @__PURE__ */ new Set();
+  const targets = /* @__PURE__ */ new Set();
+  const categoryRefs = new Set(request.categories.map((category) => category.ref));
+  const entries = [
+    ...request.categories.map((entry) => ({ entry, kind: "category" })),
+    ...request.items.map((entry) => ({ entry, kind: "product" }))
+  ];
+  for (const { entry, kind } of entries) {
+    const identity = entry.target.kind === "id" ? `${kind}:id:${entry.target.id}` : JSON.stringify([kind, "external", entry.target.namespace, entry.target.key]);
+    if (refs.has(entry.ref) || targets.has(identity)) {
+      ctx.addIssue({ code: "custom", message: "Duplicate import ref or target" });
+    }
+    refs.add(entry.ref);
+    targets.add(identity);
+  }
+  request.items.forEach((item, index) => {
+    if (item.data.category.kind === "ref" && !categoryRefs.has(item.data.category.ref)) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["items", index, "data", "category"],
+        message: "Unknown category ref"
+      });
+    }
+  });
+});
+var elenaAgentPreviewItemSchema = z4.discriminatedUnion("classification", [
+  z4.strictObject({
+    ref: elenaAgentRefSchema,
+    classification: z4.literal("create"),
+    change: elenaAgentChangeSchema,
+    diff: elenaAgentDiffSchema
+  }),
+  z4.strictObject({
+    ref: elenaAgentRefSchema,
+    classification: z4.literal("update"),
+    change: elenaAgentChangeSchema,
+    diff: elenaAgentDiffSchema
+  }),
+  z4.strictObject({
+    ref: elenaAgentRefSchema,
+    classification: z4.literal("skip"),
+    resource: z4.strictObject({
+      kind: z4.enum(["category", "product"]),
+      id: elenaAgentIdSchema,
+      revision: elenaAgentRevisionSchema
+    })
+  }),
+  z4.strictObject({
+    ref: elenaAgentRefSchema,
+    classification: z4.literal("conflict"),
+    issues: z4.array(elenaAgentItemErrorSchema).min(1).max(20)
+  }),
+  z4.strictObject({
+    ref: elenaAgentRefSchema,
+    classification: z4.literal("invalid"),
+    issues: z4.array(elenaAgentItemErrorSchema).min(1).max(20)
+  })
+]).superRefine((item, ctx) => {
+  if (item.classification !== "create" && item.classification !== "update") return;
+  const { change, diff } = item;
+  if (item.ref !== change.ref || item.ref !== diff.ref) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["ref"],
+      message: "Preview ref does not match change/diff"
+    });
+  }
+  if (diff.kind === "publication" || `${diff.kind}.upsert` !== change.kind || !normalizedValuesEqual(change, diff.after)) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["diff"],
+      message: "Preview diff must match the exact normalized change and resource kind"
+    });
+  }
+  if (diff.kind === "publication") return;
+  if (item.classification === "create") {
+    if (change.target.kind !== "external" || change.target.expectedVersion !== null || diff.before !== null) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["diff"],
+        message: "Create requires an absent external target and no previous resource"
+      });
+    }
+  } else if (change.target.expectedVersion === null || diff.before === null || diff.before.revision !== change.target.expectedVersion || change.target.kind === "id" && diff.before.id !== change.target.id) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["diff"],
+      message: "Update requires the existing target resource with its exact expected revision"
+    });
+  }
+});
+var elenaAgentImportPreviewSchema = z4.strictObject({
+  version: elenaAgentVersionSchema,
+  importId: elenaAgentIdSchema,
+  planHash: elenaAgentHashSchema,
+  createdAt: elenaAgentTimestampSchema,
+  expiresAt: elenaAgentTimestampSchema,
+  state: z4.enum(["ready", "expired"]),
+  currency: elenaAgentCurrencySchema,
+  items: z4.array(elenaAgentPreviewItemSchema).min(1).max(250),
+  summary: z4.strictObject({
+    create: z4.number().int().min(0).max(250),
+    update: z4.number().int().min(0).max(250),
+    skip: z4.number().int().min(0).max(250),
+    conflict: z4.number().int().min(0).max(250),
+    invalid: z4.number().int().min(0).max(250)
+  })
+}).superRefine((preview, ctx) => {
+  if (new Set(preview.items.map((item) => item.ref)).size !== preview.items.length) {
+    ctx.addIssue({ code: "custom", path: ["items"], message: "Duplicate preview ref" });
+  }
+  for (const classification of ["create", "update", "skip", "conflict", "invalid"]) {
+    if (preview.summary[classification] !== preview.items.filter((item) => item.classification === classification).length) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["summary", classification],
+        message: "Summary does not match items"
+      });
+    }
+  }
+});
+var elenaAgentCatalogSampleSchema = z4.strictObject({
+  version: elenaAgentVersionSchema,
+  sample: z4.literal(true),
+  disclaimer: z4.string().min(1).max(2e3),
+  source: z4.strictObject({
+    kind: z4.literal("image"),
+    label: z4.string().min(1).max(2e3),
+    originalAvailable: z4.literal(false),
+    ocrAccuracyVerified: z4.literal(false)
+  }),
+  confirmation: z4.strictObject({
+    status: z4.literal("sample_only"),
+    requiresOperatorReview: z4.literal(true),
+    currency: elenaAgentCurrencySchema
+  }),
+  categories: z4.array(z4.strictObject({ ref: elenaAgentRefSchema, name: elenaAgentNameSchema })).min(1).max(50),
+  items: z4.array(
+    z4.strictObject({
+      ref: elenaAgentRefSchema,
+      categoryRef: elenaAgentRefSchema,
+      name: elenaAgentNameSchema,
+      price: z4.discriminatedUnion("status", [
+        elenaAgentDraftPriceSchema.options[0].extend({ basis: z4.literal("sample") }),
+        elenaAgentDraftPriceSchema.options[1]
+      ]),
+      description: elenaAgentDescriptionSchema.nullable()
+    })
+  ).min(1).max(200),
+  notes: z4.array(z4.string().min(1).max(2e3)).min(1).max(30)
+}).superRefine((sample, ctx) => {
+  const categoryRefs = new Set(sample.categories.map((category) => category.ref));
+  const refs = [
+    ...sample.categories.map((category) => category.ref),
+    ...sample.items.map((item) => item.ref)
+  ];
+  if (new Set(refs).size !== refs.length)
+    ctx.addIssue({ code: "custom", message: "Duplicate sample ref" });
+  if (sample.items.some((item) => !categoryRefs.has(item.categoryRef))) {
+    ctx.addIssue({ code: "custom", path: ["items"], message: "Unknown sample category" });
+  }
+});
+
+// ../shared/src/agent-contracts/public-connection.ts
+import { z as z5 } from "zod";
+var ELENA_PUBLIC_CONNECTION_DISCOVERY_ROOT = "/api/v1/public/catalog-connections";
+var elenaPublicConnectionSlugSchema = z5.string().min(1).max(120).regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/);
+var ttl = z5.number().int().min(3600).max(ELENA_AGENT_LIMITS.keyMaxTtlSeconds).default(ELENA_AGENT_LIMITS.keyDefaultTtlSeconds);
+var mutation = {
+  version: elenaAgentVersionSchema,
+  // Zero asserts that no connection has ever been created for this restaurant.
+  expectedRevision: z5.number().int().min(0).max(Number.MAX_SAFE_INTEGER - 1)
+};
+var elenaPublicConnectionMutationSchema = z5.discriminatedUnion("action", [
+  z5.strictObject({ ...mutation, action: z5.literal("enable"), ttlSeconds: ttl }),
+  z5.strictObject({ ...mutation, action: z5.literal("renew"), ttlSeconds: ttl }),
+  z5.strictObject({ ...mutation, action: z5.literal("disable") }),
+  z5.strictObject({ ...mutation, action: z5.literal("revoke") })
+]);
+var elenaPublicConnectionMetadataSchema = z5.strictObject({
+  revision: elenaAgentRevisionSchema,
+  status: z5.enum(["published", "disabled", "revoked"]),
+  expiresAt: elenaAgentTimestampSchema
+});
+var elenaPublicConnectionManagementSchema = z5.strictObject({
+  version: elenaAgentVersionSchema,
+  publication: elenaPublicConnectionMetadataSchema.nullable()
+});
+var elenaPublicConnectionSchema = z5.strictObject({
+  version: elenaAgentVersionSchema,
+  apiOrigin: elenaAgentBaseUrlSchema,
+  clientKey: elenaManagedClientKeySchema,
+  publication: z5.strictObject({
+    revision: elenaAgentRevisionSchema,
+    expiresAt: elenaAgentTimestampSchema
+  }),
+  context: elenaClientContextSchema
+});
+
+// src/key-transport.ts
+var ElenaAgentTransportError = class extends Error {
+  constructor(code, status = 0, retryable = false, requestId = null, retryAfterSeconds) {
+    super(`Elena request failed (${code}).`);
+    this.code = code;
+    this.status = status;
+    this.retryable = retryable;
+    this.requestId = requestId;
+    this.retryAfterSeconds = retryAfterSeconds;
+  }
+  code;
+  status;
+  retryable;
+  requestId;
+  retryAfterSeconds;
+  name = "ElenaAgentTransportError";
+};
+function parseWire(schema, value, response = false) {
+  let unsupportedVersion = false;
+  try {
+    if (value !== null && typeof value === "object" && "version" in value) {
+      unsupportedVersion = value.version !== void 0 && value.version !== "1";
+    }
+    const parsed = schema.safeParse(value);
+    if (parsed.success) return parsed.data;
+  } catch {
+  }
+  throw new ElenaAgentTransportError(
+    unsupportedVersion ? "UNSUPPORTED_VERSION" : response ? "INVALID_RESPONSE" : "INVALID_REQUEST"
+  );
+}
+function assertOptionKeys(value, keys) {
+  if (!value || typeof value !== "object" || Object.keys(value).some((key) => !keys.includes(key))) {
+    throw new ElenaAgentTransportError("INVALID_REQUEST");
+  }
+}
+function explicitOrigin(value, allowTestHttp = false) {
+  try {
+    if (typeof value !== "string" || !/^https?:\/\/[^/?#@\\\s]+\/?$/.test(value)) throw 0;
+    if (/elena_(?:sk|pk)_/i.test(value)) throw 0;
+    const url = new URL(value);
+    const loopback = ["localhost", "127.0.0.1", "[::1]"].includes(url.hostname);
+    if (url.protocol !== "https:" && !(url.protocol === "http:" && (typeof process !== "undefined" && process.env.NODE_ENV === "development" || allowTestHttp && loopback)))
+      throw 0;
+    if (url.username || url.password || url.search || url.hash || url.pathname !== "/") throw 0;
+    return url.origin;
+  } catch {
+    throw new ElenaAgentTransportError("ORIGIN_REJECTED");
+  }
+}
+function resourceId(value) {
+  return parseWire(elenaAgentIdSchema, value);
+}
+function pageQuery(value = { version: "1" }) {
+  const query = parseWire(elenaAgentPageQuerySchema, value);
+  const params = new URLSearchParams({ version: query.version, limit: String(query.limit) });
+  if (query.cursor !== void 0) params.set("cursor", query.cursor);
+  return `?${params}`;
+}
+function jsonBody(schema, value) {
+  const text = JSON.stringify(parseWire(schema, value));
+  if (new TextEncoder().encode(text).byteLength > ELENA_AGENT_LIMITS.jsonBytes) {
+    throw new ElenaAgentTransportError("INVALID_REQUEST");
+  }
+  return text;
+}
+function timeoutValue(value) {
+  if (!Number.isInteger(value) || value < 1 || value > 3e5) {
+    throw new ElenaAgentTransportError("INVALID_REQUEST");
+  }
+  return value;
+}
+var privateCredential = /elena_sk_[A-Za-z0-9_-]{43}/;
+var retryCodes = {
+  RATE_LIMITED: true,
+  TEMPORARY_UNAVAILABLE: true
+};
+function createKeyTransport(options, header, credential) {
+  if (options.testing !== void 0) {
+    assertOptionKeys(options.testing, ["allowHttp"]);
+    if (options.testing.allowHttp !== true || !options.fetch) {
+      throw new ElenaAgentTransportError("INVALID_REQUEST");
+    }
+  }
+  const baseUrl = explicitOrigin(options.baseUrl, options.testing?.allowHttp === true);
+  const fetchImpl = options.fetch ?? globalThis.fetch;
+  if (typeof fetchImpl !== "function") throw new ElenaAgentTransportError("INVALID_REQUEST");
+  const defaultTimeout = timeoutValue(options.timeoutMs ?? 3e4);
+  const retries = options.maxRetries ?? 2;
+  if (!Number.isInteger(retries) || retries < 0 || retries > 2) {
+    throw new ElenaAgentTransportError("INVALID_REQUEST");
+  }
+  async function request(path, schema, requestOptions = {}, body, stage = false, retryAmbiguous = true) {
+    assertOptionKeys(requestOptions, ["signal", "timeoutMs"]);
+    if (privateCredential.test(path) || credential && path.includes(credential) || typeof body === "string" && (privateCredential.test(body) || credential && body.includes(credential))) {
+      throw new ElenaAgentTransportError("INVALID_REQUEST");
+    }
+    if (requestOptions.signal !== void 0 && !(requestOptions.signal instanceof AbortSignal)) {
+      throw new ElenaAgentTransportError("INVALID_REQUEST");
+    }
+    const timeoutMs = timeoutValue(requestOptions.timeoutMs ?? (stage ? 12e4 : defaultTimeout));
+    if (requestOptions.signal?.aborted) throw new ElenaAgentTransportError("ABORTED");
+    const controller = new AbortController();
+    let timedOut = false;
+    const timer = setTimeout(() => {
+      timedOut = true;
+      controller.abort();
+    }, timeoutMs);
+    const onAbort = () => controller.abort();
+    requestOptions.signal?.addEventListener("abort", onAbort, { once: true });
+    const abortError = () => new ElenaAgentTransportError(timedOut ? "TIMEOUT" : "ABORTED");
+    const deadline = Date.now() + timeoutMs;
+    const bounded = (promise) => new Promise((resolve, reject) => {
+      const abort = () => {
+        cleanup();
+        reject(abortError());
+      };
+      const cleanup = () => controller.signal.removeEventListener("abort", abort);
+      if (controller.signal.aborted) {
+        reject(abortError());
+        return;
+      }
+      controller.signal.addEventListener("abort", abort, { once: true });
+      promise.then(
+        (value) => {
+          cleanup();
+          resolve(value);
+        },
+        (error) => {
+          cleanup();
+          reject(error);
+        }
+      );
+    });
+    const delay = (ms) => new Promise((resolve, reject) => {
+      const abort = () => {
+        clearTimeout(wait);
+        controller.signal.removeEventListener("abort", abort);
+        reject(abortError());
+      };
+      const wait = setTimeout(() => {
+        controller.signal.removeEventListener("abort", abort);
+        resolve();
+      }, ms);
+      controller.signal.addEventListener("abort", abort, { once: true });
+      if (controller.signal.aborted) abort();
+    });
+    try {
+      for (let attempt = 0; ; attempt++) {
+        let failure;
+        let retryDelay = 100 * 2 ** attempt;
+        try {
+          const headers = new Headers({ Accept: "application/json" });
+          if (header) headers.set(header, credential);
+          if (typeof body === "string") headers.set("Content-Type", "application/json");
+          const response = await bounded(
+            Promise.resolve().then(() => {
+              if (controller.signal.aborted) throw abortError();
+              return fetchImpl(`${baseUrl}${path}`, {
+                method: body === void 0 ? "GET" : "POST",
+                headers,
+                body: typeof body === "function" ? body() : body,
+                credentials: "omit",
+                redirect: "error",
+                referrerPolicy: "no-referrer",
+                cache: "no-store",
+                signal: controller.signal
+              });
+            }).catch(() => {
+              throw new ElenaAgentTransportError("NETWORK_ERROR", 0, retryAmbiguous);
+            })
+          );
+          if (response.redirected || response.status >= 300 && response.status < 400) {
+            throw new ElenaAgentTransportError("REDIRECT_REJECTED", response.status);
+          }
+          if (response.url && new URL(response.url).origin !== baseUrl) {
+            throw new ElenaAgentTransportError("ORIGIN_REJECTED");
+          }
+          const text = await bounded(
+            Promise.resolve().then(() => response.text()).catch(() => {
+              throw new ElenaAgentTransportError("NETWORK_ERROR", 0, retryAmbiguous);
+            })
+          );
+          if (privateCredential.test(text) || credential && text.includes(credential)) {
+            throw new ElenaAgentTransportError("INVALID_RESPONSE", response.status);
+          }
+          let payload;
+          try {
+            payload = JSON.parse(text);
+          } catch {
+            throw new ElenaAgentTransportError("INVALID_RESPONSE", response.status);
+          }
+          const decodedText = JSON.stringify(payload);
+          if (privateCredential.test(decodedText) || credential && decodedText.includes(credential)) {
+            throw new ElenaAgentTransportError("INVALID_RESPONSE", response.status);
+          }
+          if (response.ok) return parseWire(schema, payload, true);
+          const wire = parseWire(elenaAgentErrorSchema, payload, true).error;
+          const retryable = retryCodes[wire.code] === true && wire.retryable && (wire.code === "RATE_LIMITED" && response.status === 429 || wire.code === "TEMPORARY_UNAVAILABLE" && response.status === 503);
+          failure = new ElenaAgentTransportError(
+            wire.code,
+            response.status,
+            retryable,
+            wire.requestId,
+            wire.retryAfterSeconds
+          );
+          const retryAfter = response.headers.get("retry-after");
+          let headerDelay = 0;
+          if (retryAfter !== null) {
+            const seconds = /^\d+$/.test(retryAfter) ? Number(retryAfter) : (Date.parse(retryAfter) - Date.now()) / 1e3;
+            if (!Number.isFinite(seconds) || seconds < 0 || seconds > 3600) {
+              throw new ElenaAgentTransportError(
+                wire.code,
+                response.status,
+                false,
+                wire.requestId,
+                wire.retryAfterSeconds
+              );
+            }
+            headerDelay = Math.ceil(seconds * 1e3);
+          }
+          retryDelay = Math.max(retryDelay, headerDelay, (wire.retryAfterSeconds ?? 0) * 1e3);
+        } catch (error) {
+          if (controller.signal.aborted) throw abortError();
+          failure = error instanceof ElenaAgentTransportError ? error : new ElenaAgentTransportError("NETWORK_ERROR", 0, retryAmbiguous);
+        }
+        if (!failure.retryable || attempt >= retries || Date.now() + retryDelay >= deadline)
+          throw failure;
+        await delay(retryDelay);
+      }
+    } finally {
+      clearTimeout(timer);
+      requestOptions.signal?.removeEventListener("abort", onAbort);
+    }
+  }
+  return { request };
+}
+
+// src/agent/index.ts
+function assertServerRuntime() {
+  if (typeof window !== "undefined" || typeof document !== "undefined" || typeof process === "undefined" || typeof process.versions?.node !== "string") {
+    throw new Error("Elena agent client is server-only.");
+  }
+}
+assertServerRuntime();
+function createElenaAgentClient(options) {
+  assertServerRuntime();
+  assertOptionKeys(options, [
+    "baseUrl",
+    "agentKey",
+    "staffOrigin",
+    "fetch",
+    "timeoutMs",
+    "maxRetries",
+    "testing"
+  ]);
+  if (!elenaAgentSecretSchema.safeParse(options.agentKey).success) {
+    throw new ElenaAgentTransportError("CREDENTIAL_WRONG_FAMILY");
+  }
+  const { request } = createKeyTransport(options, "x-elena-agent-key", options.agentKey);
+  const staffOrigin = options.staffOrigin === void 0 ? void 0 : explicitOrigin(options.staffOrigin);
+  const root = "/api/v1/agent";
+  function requireStaffOrigin() {
+    if (!staffOrigin) throw new ElenaAgentTransportError("ORIGIN_REJECTED");
+  }
+  function operationResponse(operation, id, hash) {
+    requireStaffOrigin();
+    const approval = new URL(operation.approvalUrl);
+    if (approval.origin !== staffOrigin || approval.pathname !== `/agent-operations/${operation.operationId}` || approval.search || approval.hash || id !== void 0 && operation.operationId !== id || hash !== void 0 && operation.payloadHash !== hash) {
+      throw new ElenaAgentTransportError("INVALID_RESPONSE");
+    }
+    return operation;
+  }
+  async function getOperation(id, requestOptions) {
+    requireStaffOrigin();
+    const expectedId = resourceId(id);
+    return operationResponse(
+      await request(
+        `${root}/operations/${expectedId}`,
+        elenaAgentOperationSchema,
+        requestOptions
+      ),
+      expectedId
+    );
+  }
+  return Object.freeze({
+    context: Object.freeze({
+      get: (options2) => request(`${root}/context`, elenaAgentContextSchema, options2)
+    }),
+    catalog: Object.freeze({
+      categories: Object.freeze({
+        list: (query, options2) => request(
+          `${root}/catalog/categories${pageQuery(query)}`,
+          elenaAgentCategoryListSchema,
+          options2
+        ),
+        get: async (id, options2) => {
+          const expectedId = resourceId(id);
+          const result = await request(
+            `${root}/catalog/categories/${expectedId}`,
+            elenaAgentCategoryResponseSchema,
+            options2
+          );
+          if (result.category.id !== expectedId)
+            throw new ElenaAgentTransportError("INVALID_RESPONSE");
+          return result;
+        }
+      }),
+      products: Object.freeze({
+        list: (query, options2) => request(
+          `${root}/catalog/products${pageQuery(query)}`,
+          elenaAgentProductListSchema,
+          options2
+        ),
+        get: async (id, options2) => {
+          const expectedId = resourceId(id);
+          const result = await request(
+            `${root}/catalog/products/${expectedId}`,
+            elenaAgentProductResponseSchema,
+            options2
+          );
+          if (result.product.id !== expectedId)
+            throw new ElenaAgentTransportError("INVALID_RESPONSE");
+          return result;
+        }
+      })
+    }),
+    assets: Object.freeze({
+      get: async (id, options2) => {
+        const expectedId = resourceId(id);
+        const result = await request(
+          `${root}/assets/${expectedId}`,
+          elenaAgentAssetSchema,
+          options2
+        );
+        if (result.assetId !== expectedId) throw new ElenaAgentTransportError("INVALID_RESPONSE");
+        return result;
+      }
+    }),
+    media: Object.freeze({
+      stage: async (input, file, options2) => {
+        const metadata = parseWire(elenaAgentMediaStageRequestSchema, input);
+        const requestOptions = options2 ?? {};
+        assertOptionKeys(requestOptions, ["signal", "timeoutMs"]);
+        const timeoutMs = requestOptions.timeoutMs ?? 12e4;
+        if (!Number.isInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > 3e5 || requestOptions.signal !== void 0 && !(requestOptions.signal instanceof AbortSignal)) {
+          throw new ElenaAgentTransportError("INVALID_REQUEST");
+        }
+        if (requestOptions.signal?.aborted) throw new ElenaAgentTransportError("ABORTED");
+        const deadline = Date.now() + timeoutMs;
+        let readTimer;
+        let readTimedOut = false;
+        let onAbort;
+        let snapshot;
+        let hash;
+        try {
+          if (!(file instanceof Blob) || file.size !== metadata.bytes || file.type !== metadata.mimeType) {
+            throw new Error("Invalid media");
+          }
+          const boundedFile = Blob.prototype.slice.call(file, 0, metadata.bytes, metadata.mimeType);
+          const reading = Blob.prototype.arrayBuffer.call(boundedFile);
+          const interrupted = new Promise((_, reject) => {
+            readTimer = setTimeout(() => {
+              readTimedOut = true;
+              reject(new Error("Read timeout"));
+            }, timeoutMs);
+            onAbort = () => reject(new Error("Read aborted"));
+            requestOptions.signal?.addEventListener("abort", onAbort, { once: true });
+            if (requestOptions.signal?.aborted) onAbort();
+          });
+          const bytes = await Promise.race([reading, interrupted]);
+          if (bytes.byteLength !== metadata.bytes) throw new Error("Invalid media");
+          hash = createHash("sha256").update(new Uint8Array(bytes)).digest("hex");
+          if (hash !== metadata.sha256) throw new Error("Invalid media");
+          snapshot = new Blob([bytes], { type: metadata.mimeType });
+        } catch {
+          throw new ElenaAgentTransportError(
+            requestOptions.signal?.aborted ? "ABORTED" : readTimedOut || Date.now() >= deadline ? "TIMEOUT" : "MEDIA_INVALID"
+          );
+        } finally {
+          clearTimeout(readTimer);
+          if (onAbort) requestOptions.signal?.removeEventListener("abort", onAbort);
+        }
+        const remainingMs = deadline - Date.now();
+        if (remainingMs <= 0) throw new ElenaAgentTransportError("TIMEOUT");
+        const result = await request(
+          `${root}/media/stage`,
+          elenaAgentMediaStagedSchema,
+          { ...requestOptions, timeoutMs: remainingMs },
+          () => {
+            const form = new FormData();
+            form.set("metadata", JSON.stringify(metadata));
+            form.set("file", snapshot, metadata.fileName);
+            return form;
+          },
+          true
+        );
+        if (result.sha256 !== hash || result.bytes !== metadata.bytes || result.mimeType !== metadata.mimeType) {
+          throw new ElenaAgentTransportError("INVALID_RESPONSE");
+        }
+        return result;
+      },
+      get: async (id, options2) => {
+        const expectedId = resourceId(id);
+        const result = await request(
+          `${root}/media/staged/${expectedId}`,
+          elenaAgentMediaStagedSchema,
+          options2
+        );
+        if (result.stagingId !== expectedId) throw new ElenaAgentTransportError("INVALID_RESPONSE");
+        return result;
+      }
+    }),
+    imports: Object.freeze({
+      preview: async (input, options2) => {
+        const normalized = parseWire(elenaAgentImportPreviewRequestSchema, input);
+        const refs = new Set(
+          [...normalized.categories, ...normalized.items].map((item) => item.ref)
+        );
+        const result = await request(
+          `${root}/imports/preview`,
+          elenaAgentImportPreviewSchema,
+          options2,
+          jsonBody(elenaAgentImportPreviewRequestSchema, normalized)
+        );
+        if (result.items.length !== refs.size || result.items.some((item) => !refs.has(item.ref))) {
+          throw new ElenaAgentTransportError("INVALID_RESPONSE");
+        }
+        return result;
+      },
+      get: async (id, options2) => {
+        const expectedId = resourceId(id);
+        const result = await request(
+          `${root}/imports/${expectedId}`,
+          elenaAgentImportPreviewSchema,
+          options2
+        );
+        if (result.importId !== expectedId) throw new ElenaAgentTransportError("INVALID_RESPONSE");
+        return result;
+      }
+    }),
+    operations: Object.freeze({
+      propose: async (input, options2) => {
+        requireStaffOrigin();
+        return operationResponse(
+          await request(
+            `${root}/operations`,
+            elenaAgentOperationSchema,
+            options2,
+            jsonBody(elenaAgentProposalRequestSchema, input)
+          )
+        );
+      },
+      list: async (query, options2) => {
+        requireStaffOrigin();
+        const result = await request(
+          `${root}/operations${pageQuery(query)}`,
+          elenaAgentOperationListSchema,
+          options2
+        );
+        result.operations.forEach((operation) => operationResponse(operation));
+        return result;
+      },
+      get: getOperation,
+      apply: async (id, input, options2) => {
+        requireStaffOrigin();
+        const expectedId = resourceId(id);
+        const normalized = parseWire(elenaAgentApplyRequestSchema, input);
+        const body = jsonBody(elenaAgentApplyRequestSchema, normalized);
+        const { payloadHash } = normalized;
+        if (options2?.signal?.aborted) throw new ElenaAgentTransportError("ABORTED");
+        try {
+          return operationResponse(
+            await request(
+              `${root}/operations/${expectedId}/apply`,
+              elenaAgentOperationSchema,
+              options2,
+              body,
+              false,
+              false
+            ),
+            expectedId,
+            payloadHash
+          );
+        } catch (error) {
+          if (!(error instanceof ElenaAgentTransportError) || !["NETWORK_ERROR", "TIMEOUT", "ABORTED"].includes(error.code))
+            throw error;
+          try {
+            const current = operationResponse(
+              await getOperation(expectedId, { timeoutMs: 3e4 }),
+              expectedId,
+              payloadHash
+            );
+            if (["applying", "applied", "partial", "failed", "cancelled"].includes(current.state))
+              return current;
+          } catch {
+          }
+          throw error;
+        }
+      }
+    })
+  });
+}
+export {
+  ELENA_AGENT_CONTRACT_VERSION,
+  ELENA_AGENT_LIMITS,
+  ELENA_AGENT_TRANSPORT,
+  ELENA_PUBLIC_CONNECTION_DISCOVERY_ROOT,
+  ElenaAgentTransportError,
+  createElenaAgentClient,
+  elenaAgentAckSchema,
+  elenaAgentActionSchema,
+  elenaAgentApplyRequestSchema,
+  elenaAgentApprovalRequestSchema,
+  elenaAgentAssetSchema,
+  elenaAgentBaseUrlSchema,
+  elenaAgentBaseVersionSchema,
+  elenaAgentCatalogSampleSchema,
+  elenaAgentCategoryChangeSchema,
+  elenaAgentCategoryDataSchema,
+  elenaAgentCategoryListSchema,
+  elenaAgentCategoryReferenceSchema,
+  elenaAgentCategoryResponseSchema,
+  elenaAgentCategorySchema,
+  elenaAgentChangeSchema,
+  elenaAgentChangesSchema,
+  elenaAgentCliAuthStatusSchema,
+  elenaAgentCliLogoutSchema,
+  elenaAgentConfirmedPriceSchema,
+  elenaAgentConnectionOriginSchema,
+  elenaAgentConnectionUrlSchema,
+  elenaAgentContextSchema,
+  elenaAgentCurrencySchema,
+  elenaAgentDescriptionSchema,
+  elenaAgentDeviceCodeSchema,
+  elenaAgentDiffSchema,
+  elenaAgentDraftPriceSchema,
+  elenaAgentDraftProductDataSchema,
+  elenaAgentEmptyRequestSchema,
+  elenaAgentErrorCodeSchema,
+  elenaAgentErrorSchema,
+  elenaAgentExistingTargetSchema,
+  elenaAgentExternalTargetSchema,
+  elenaAgentExtraGroupSchema,
+  elenaAgentExtraOptionSchema,
+  elenaAgentExtrasSchema,
+  elenaAgentGallerySchema,
+  elenaAgentHashSchema,
+  elenaAgentHttpsUrlSchema,
+  elenaAgentIdSchema,
+  elenaAgentImportItemSchema,
+  elenaAgentImportPreviewRequestSchema,
+  elenaAgentImportPreviewSchema,
+  elenaAgentImportSourceSchema,
+  elenaAgentItemErrorSchema,
+  elenaAgentKeyCreateRequestSchema,
+  elenaAgentKeyListSchema,
+  elenaAgentKeyMetadataSchema,
+  elenaAgentKeyPolicyRequestSchema,
+  elenaAgentKeyReceiptSchema,
+  elenaAgentKeyReplaceRequestSchema,
+  elenaAgentKeyResponseSchema,
+  elenaAgentKeyRevokeRequestSchema,
+  elenaAgentMediaReferenceSchema,
+  elenaAgentMediaStageRequestSchema,
+  elenaAgentMediaStagedSchema,
+  elenaAgentModeSchema,
+  elenaAgentMoneySchema,
+  elenaAgentNameSchema,
+  elenaAgentNonnegativeMoneySchema,
+  elenaAgentOperationListSchema,
+  elenaAgentOperationPayloadSchema,
+  elenaAgentOperationResultSchema,
+  elenaAgentOperationSchema,
+  elenaAgentOperationStateSchema,
+  elenaAgentPageQuerySchema,
+  elenaAgentPairingDecisionRequestSchema,
+  elenaAgentPairingPollRequestSchema,
+  elenaAgentPairingPollResponseSchema,
+  elenaAgentPairingReviewSchema,
+  elenaAgentPairingStartRequestSchema,
+  elenaAgentPairingStartResponseSchema,
+  elenaAgentPreviewItemSchema,
+  elenaAgentProductChangeSchema,
+  elenaAgentProductDataSchema,
+  elenaAgentProductListSchema,
+  elenaAgentProductResponseSchema,
+  elenaAgentProductSchema,
+  elenaAgentProposalRequestSchema,
+  elenaAgentPublicationPayloadSchema,
+  elenaAgentRefSchema,
+  elenaAgentRestaurantSchema,
+  elenaAgentResultItemSchema,
+  elenaAgentRevisionSchema,
+  elenaAgentScopeSchema,
+  elenaAgentScopesSchema,
+  elenaAgentSecretSchema,
+  elenaAgentTargetSchema,
+  elenaAgentTextSchema,
+  elenaAgentTimestampSchema,
+  elenaAgentUserCodeSchema,
+  elenaAgentVersionSchema,
+  elenaClientAssetResponseSchema,
+  elenaClientAssetSchema,
+  elenaClientCatalogSchema,
+  elenaClientCategorySchema,
+  elenaClientContextSchema,
+  elenaClientKeySchema,
+  elenaClientProductResponseSchema,
+  elenaClientProductSchema,
+  elenaManagedClientKeySchema,
+  elenaManualClientKeySchema,
+  elenaPublicConnectionManagementSchema,
+  elenaPublicConnectionMetadataSchema,
+  elenaPublicConnectionMutationSchema,
+  elenaPublicConnectionSchema,
+  elenaPublicConnectionSlugSchema
+};
+//# sourceMappingURL=agent.js.map