@opengeni/contracts 0.40.0 → 0.50.0

package/dist/workspace-learning-policy.d.ts

@@ -0,0 +1,208 @@
+import { z } from "zod";
+export declare const WORKSPACE_LEARNING_POLICY_MAX_SOURCE_OVERRIDES = 256;
+export declare const WORKSPACE_LEARNING_POLICY_SOURCE_KIND_MAX_CHARS = 96;
+export declare const WORKSPACE_LEARNING_POLICY_SOURCE_ID_MAX_CHARS = 1024;
+export declare const WORKSPACE_LEARNING_POLICY_REASON_MAX_CHARS = 4096;
+export declare const WORKSPACE_LEARNING_POLICY_DEFAULT_OFF_REVISION_ID = "workspace-learning-policy:default-off:v1";
+export declare const WorkspaceLearningMode: z.ZodEnum<{
+    automatic: "automatic";
+    off: "off";
+    suggest: "suggest";
+}>;
+export type WorkspaceLearningMode = z.infer<typeof WorkspaceLearningMode>;
+export declare const WorkspaceLearningOverrideMode: z.ZodEnum<{
+    automatic: "automatic";
+    inherit: "inherit";
+    off: "off";
+    suggest: "suggest";
+}>;
+export type WorkspaceLearningOverrideMode = z.infer<typeof WorkspaceLearningOverrideMode>;
+export declare function normalizeWorkspaceLearningSourceKind(value: string): string;
+export declare const WorkspaceLearningSourceKind: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodString>;
+export type WorkspaceLearningSourceKind = z.infer<typeof WorkspaceLearningSourceKind>;
+export declare const WorkspaceLearningSourceId: z.ZodString;
+export type WorkspaceLearningSourceId = z.infer<typeof WorkspaceLearningSourceId>;
+export declare const WorkspaceLearningSourceRef: z.ZodObject<{
+    kind: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodString>;
+    id: z.ZodString;
+}, z.core.$strip>;
+export type WorkspaceLearningSourceRef = z.infer<typeof WorkspaceLearningSourceRef>;
+export declare const WorkspaceLearningSourceOverrideInput: z.ZodObject<{
+    kind: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodString>;
+    id: z.ZodString;
+    mode: z.ZodEnum<{
+        automatic: "automatic";
+        inherit: "inherit";
+        off: "off";
+        suggest: "suggest";
+    }>;
+}, z.core.$strip>;
+export type WorkspaceLearningSourceOverrideInput = z.infer<typeof WorkspaceLearningSourceOverrideInput>;
+export declare const WorkspaceLearningSourceOverride: z.ZodObject<{
+    kind: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodString>;
+    id: z.ZodString;
+    mode: z.ZodEnum<{
+        automatic: "automatic";
+        off: "off";
+        suggest: "suggest";
+    }>;
+}, z.core.$strip>;
+export type WorkspaceLearningSourceOverride = z.infer<typeof WorkspaceLearningSourceOverride>;
+export declare const WorkspaceLearningSourceOverrides: z.ZodArray<z.ZodObject<{
+    kind: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodString>;
+    id: z.ZodString;
+    mode: z.ZodEnum<{
+        automatic: "automatic";
+        off: "off";
+        suggest: "suggest";
+    }>;
+}, z.core.$strip>>;
+export type WorkspaceLearningSourceOverrides = z.infer<typeof WorkspaceLearningSourceOverrides>;
+export declare function workspaceLearningSourceKey(source: WorkspaceLearningSourceRef): string;
+/**
+ * Canonicalize caller input before hashing or persistence. `inherit` is a
+ * request-only reset operation: inherited entries are deliberately absent from
+ * immutable revisions so the persisted policy stays sparse and transparent.
+ */
+export declare function canonicalizeWorkspaceLearningSourceOverrides(input: readonly WorkspaceLearningSourceOverrideInput[]): WorkspaceLearningSourceOverride[];
+export declare const WorkspaceLearningPolicyRevisionIdentity: z.ZodObject<{
+    id: z.ZodString;
+    revision: z.ZodNumber;
+    policyHash: z.ZodString;
+}, z.core.$strip>;
+export type WorkspaceLearningPolicyRevisionIdentity = z.infer<typeof WorkspaceLearningPolicyRevisionIdentity>;
+export declare const WorkspaceLearningPolicyRevision: z.ZodObject<{
+    id: z.ZodString;
+    revision: z.ZodNumber;
+    policyHash: z.ZodString;
+    operationId: z.ZodString;
+    accountId: z.ZodString;
+    workspaceId: z.ZodString;
+    workspaceMode: z.ZodEnum<{
+        automatic: "automatic";
+        off: "off";
+        suggest: "suggest";
+    }>;
+    sourceOverrides: z.ZodArray<z.ZodObject<{
+        kind: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodString>;
+        id: z.ZodString;
+        mode: z.ZodEnum<{
+            automatic: "automatic";
+            off: "off";
+            suggest: "suggest";
+        }>;
+    }, z.core.$strip>>;
+    supersedesRevisionId: z.ZodNullable<z.ZodString>;
+    createdBySubjectId: z.ZodString;
+    createdAt: z.ZodString;
+}, z.core.$strip>;
+export type WorkspaceLearningPolicyRevision = z.infer<typeof WorkspaceLearningPolicyRevision>;
+export declare const WorkspaceLearningPolicyHead: z.ZodObject<{
+    accountId: z.ZodString;
+    workspaceId: z.ZodString;
+    revisionId: z.ZodString;
+    revision: z.ZodNumber;
+    policyHash: z.ZodString;
+    activationVersion: z.ZodNumber;
+    activatedAt: z.ZodString;
+}, z.core.$strip>;
+export type WorkspaceLearningPolicyHead = z.infer<typeof WorkspaceLearningPolicyHead>;
+export declare const WorkspaceLearningPolicyActivationType: z.ZodEnum<{
+    activate: "activate";
+    rollback: "rollback";
+}>;
+export type WorkspaceLearningPolicyActivationType = z.infer<typeof WorkspaceLearningPolicyActivationType>;
+export declare const WorkspaceLearningPolicyActivationEvent: z.ZodObject<{
+    id: z.ZodString;
+    operationId: z.ZodString;
+    accountId: z.ZodString;
+    workspaceId: z.ZodString;
+    type: z.ZodEnum<{
+        activate: "activate";
+        rollback: "rollback";
+    }>;
+    activationVersion: z.ZodNumber;
+    oldRevision: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodNumber;
+        policyHash: z.ZodString;
+    }, z.core.$strip>>;
+    newRevision: z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodNumber;
+        policyHash: z.ZodString;
+    }, z.core.$strip>;
+    actorSubjectId: z.ZodString;
+    reason: z.ZodString;
+    createdAt: z.ZodString;
+}, z.core.$strip>;
+export type WorkspaceLearningPolicyActivationEvent = z.infer<typeof WorkspaceLearningPolicyActivationEvent>;
+export declare const WorkspaceLearningPolicySnapshot: z.ZodObject<{
+    id: z.ZodString;
+    accountId: z.ZodString;
+    workspaceId: z.ZodString;
+    sessionId: z.ZodString;
+    turnId: z.ZodString;
+    attemptId: z.ZodString;
+    executionGeneration: z.ZodNumber;
+    revision: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodNumber;
+        policyHash: z.ZodString;
+    }, z.core.$strip>>;
+    activationVersion: z.ZodNumber;
+    activatedAt: z.ZodNullable<z.ZodString>;
+    workspaceMode: z.ZodEnum<{
+        automatic: "automatic";
+        off: "off";
+        suggest: "suggest";
+    }>;
+    sourceOverrides: z.ZodArray<z.ZodObject<{
+        kind: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodString>;
+        id: z.ZodString;
+        mode: z.ZodEnum<{
+            automatic: "automatic";
+            off: "off";
+            suggest: "suggest";
+        }>;
+    }, z.core.$strip>>;
+    snapshotHash: z.ZodString;
+    createdAt: z.ZodString;
+}, z.core.$strip>;
+export type WorkspaceLearningPolicySnapshot = z.infer<typeof WorkspaceLearningPolicySnapshot>;
+export declare const WorkspaceLearningPolicyRouterContext: z.ZodObject<{
+    mode: z.ZodEnum<{
+        automatic: "automatic";
+        off: "off";
+        suggest: "suggest";
+    }>;
+    snapshotId: z.ZodString;
+    revisionId: z.ZodString;
+}, z.core.$strip>;
+export type WorkspaceLearningPolicyRouterContext = z.infer<typeof WorkspaceLearningPolicyRouterContext>;
+export declare const WorkspaceLearningPolicyEffectiveMode: z.ZodObject<{
+    mode: z.ZodEnum<{
+        automatic: "automatic";
+        off: "off";
+        suggest: "suggest";
+    }>;
+    snapshotId: z.ZodString;
+    revisionId: z.ZodString;
+    inherited: z.ZodBoolean;
+    source: z.ZodObject<{
+        kind: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodString>;
+        id: z.ZodString;
+    }, z.core.$strip>;
+    policyRevision: z.ZodNullable<z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodNumber;
+        policyHash: z.ZodString;
+    }, z.core.$strip>>;
+    activationVersion: z.ZodNumber;
+    snapshotHash: z.ZodString;
+}, z.core.$strip>;
+export type WorkspaceLearningPolicyEffectiveMode = z.infer<typeof WorkspaceLearningPolicyEffectiveMode>;
+/** Stable router seam: resolve only from an immutable accepted-attempt snapshot. */
+export declare function resolveWorkspaceLearningPolicyEffectiveMode(snapshot: WorkspaceLearningPolicySnapshot, source: WorkspaceLearningSourceRef): WorkspaceLearningPolicyEffectiveMode;
+/** Exact provider-neutral context consumed by the canonical durable-learning router. */
+export declare function workspaceLearningPolicyRouterContext(effectiveMode: WorkspaceLearningPolicyEffectiveMode): WorkspaceLearningPolicyRouterContext;

package/dist/xai-provider-account-authority.d.ts

@@ -0,0 +1,23 @@
+import { z } from "zod";
+/**
+ * Opaque authority frozen at an xAI provider-account acceptance boundary.
+ *
+ * This snapshot deliberately carries no organization, membership, credential,
+ * provider-account, subject, label, quota, token, or plan identity. User scope
+ * becomes executable only after exact live database revalidation against the
+ * separately stored causal subject and xAI subscription authority row.
+ */
+export declare const XaiProviderAccountAuthoritySnapshotV1: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    scope: z.ZodLiteral<"workspace">;
+}, z.core.$strict>, z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    scope: z.ZodLiteral<"user">;
+    authorityGeneration: z.ZodNumber;
+}, z.core.$strict>], "scope">;
+export type XaiProviderAccountAuthoritySnapshotV1 = z.infer<typeof XaiProviderAccountAuthoritySnapshotV1>;
+/** Explicit compatibility value for workspace-default accepted work. */
+export declare const WORKSPACE_XAI_PROVIDER_ACCOUNT_AUTHORITY_SNAPSHOT_V1: {
+    readonly version: 1;
+    readonly scope: "workspace";
+};

package/dist/xai-provider-account-authority.js

@@ -0,0 +1,9 @@
+import {
+  WORKSPACE_XAI_PROVIDER_ACCOUNT_AUTHORITY_SNAPSHOT_V1,
+  XaiProviderAccountAuthoritySnapshotV1
+} from "./chunk-CM6BMECR.js";
+export {
+  WORKSPACE_XAI_PROVIDER_ACCOUNT_AUTHORITY_SNAPSHOT_V1,
+  XaiProviderAccountAuthoritySnapshotV1
+};
+//# sourceMappingURL=xai-provider-account-authority.js.map

package/dist/xai-provider-account-authority.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opengeni/contracts",
-  "version": "0.40.0",
+  "version": "0.50.0",
   "description": "Shared zod schemas and wire-contract types for the OpenGeni API.",
   "license": "Apache-2.0",
   "repository": {
@@ -30,9 +30,81 @@
       "types": "./dist/google-drive.d.ts",
       "import": "./dist/google-drive.js"
     },
+    "./atlassian": {
+      "types": "./dist/atlassian.d.ts",
+      "import": "./dist/atlassian.js"
+    },
     "./connector-destinations": {
       "types": "./dist/connector-destinations.d.ts",
       "import": "./dist/connector-destinations.js"
+    },
+    "./video-generation": {
+      "types": "./dist/video-generation.d.ts",
+      "import": "./dist/video-generation.js"
+    },
+    "./canonical-human-identities": {
+      "types": "./dist/canonical-human-identities.d.ts",
+      "import": "./dist/canonical-human-identities.js"
+    },
+    "./codex-provider-account-authority": {
+      "types": "./dist/codex-provider-account-authority.d.ts",
+      "import": "./dist/codex-provider-account-authority.js"
+    },
+    "./xai-provider-account-authority": {
+      "types": "./dist/xai-provider-account-authority.d.ts",
+      "import": "./dist/xai-provider-account-authority.js"
+    },
+    "./editable-artifacts": {
+      "types": "./dist/editable-artifacts.d.ts",
+      "import": "./dist/editable-artifacts.js"
+    },
+    "./editable-artifact-committed-transaction": {
+      "types": "./dist/editable-artifact-committed-transaction.d.ts",
+      "import": "./dist/editable-artifact-committed-transaction.js"
+    },
+    "./editable-artifact-serialized-commit": {
+      "types": "./dist/editable-artifact-serialized-commit.d.ts",
+      "import": "./dist/editable-artifact-serialized-commit.js"
+    },
+    "./editable-artifact-live": {
+      "types": "./dist/editable-artifact-live.d.ts",
+      "import": "./dist/editable-artifact-live.js"
+    },
+    "./editable-artifact-causal-frontier": {
+      "types": "./dist/editable-artifact-causal-frontier.d.ts",
+      "import": "./dist/editable-artifact-causal-frontier.js"
+    },
+    "./editable-artifact-codec-registry": {
+      "types": "./dist/editable-artifact-codec-registry.d.ts",
+      "import": "./dist/editable-artifact-codec-registry.js"
+    },
+    "./editable-artifact-versions": {
+      "types": "./dist/editable-artifact-versions.d.ts",
+      "import": "./dist/editable-artifact-versions.js"
+    },
+    "./spreadsheet-artifact-commands": {
+      "types": "./dist/spreadsheet-artifact-commands.d.ts",
+      "import": "./dist/spreadsheet-artifact-commands.js"
+    },
+    "./spreadsheet-artifact-query": {
+      "types": "./dist/spreadsheet-artifact-query.d.ts",
+      "import": "./dist/spreadsheet-artifact-query.js"
+    },
+    "./document-artifact-commands": {
+      "types": "./dist/document-artifact-commands.d.ts",
+      "import": "./dist/document-artifact-commands.js"
+    },
+    "./document-artifact-query": {
+      "types": "./dist/document-artifact-query.d.ts",
+      "import": "./dist/document-artifact-query.js"
+    },
+    "./presentation-artifact-commands": {
+      "types": "./dist/presentation-artifact-commands.d.ts",
+      "import": "./dist/presentation-artifact-commands.js"
+    },
+    "./presentation-artifact-query": {
+      "types": "./dist/presentation-artifact-query.d.ts",
+      "import": "./dist/presentation-artifact-query.js"
     }
   },
   "publishConfig": {

package/src/artifacts.ts

@@ -1,6 +1,6 @@
 import { z } from "zod";
 
-export const WORKSPACE_ARTIFACT_HTML_MAX_UTF8_BYTES = 512 * 1024;
+export const WORKSPACE_ARTIFACT_HTML_MAX_UTF8_BYTES = 4 * 1024 * 1024;
 export const WORKSPACE_ARTIFACT_TITLE_MAX_CHARS = 120;
 export const WORKSPACE_ARTIFACT_DESCRIPTION_MAX_CHARS = 2_000;
 export const WORKSPACE_ARTIFACT_LIST_MAX = 100;

package/src/atlassian.ts

@@ -0,0 +1,160 @@
+import { z } from "zod";
+import { ConnectionMetadata } from "./index";
+import { ConnectorDocumentDestination } from "./connector-destinations";
+
+export const ATLASSIAN_PROVIDER_DOMAIN = "api.atlassian.com" as const;
+export const ATLASSIAN_CREDENTIAL_ROLE = "atlassian_knowledge" as const;
+export const ATLASSIAN_CREDENTIAL_LABEL = "Atlassian read-only knowledge sync" as const;
+
+export const ATLASSIAN_REQUIRED_SCOPES = [
+  "offline_access",
+  "read:me",
+  "read:jira-work",
+  "read:jira-user",
+  "read:confluence-content.all",
+  "read:confluence-space.summary",
+  "search:confluence",
+  "read:space:confluence",
+  "read:page:confluence",
+  "read:comment:confluence",
+] as const;
+
+export const AtlassianSourceKind = z.enum(["jira_project", "confluence_space"]);
+export type AtlassianSourceKind = z.infer<typeof AtlassianSourceKind>;
+
+export const AtlassianSyncCadence = z.enum(["manual", "hourly", "daily"]);
+export type AtlassianSyncCadence = z.infer<typeof AtlassianSyncCadence>;
+
+export const AtlassianReadPolicy = z.enum(["allow", "ask", "block"]);
+export type AtlassianReadPolicy = z.infer<typeof AtlassianReadPolicy>;
+
+export const AtlassianConnectionLifecycle = z.object({
+  state: z.enum([
+    "active",
+    "paused",
+    "token_revoked",
+    "app_removed",
+    "disconnected",
+    "reconnect_required",
+    "reconsent_required",
+  ]),
+  recoverable: z.boolean(),
+  observedAt: z.string().datetime(),
+});
+export type AtlassianConnectionLifecycle = z.infer<typeof AtlassianConnectionLifecycle>;
+
+export const AtlassianSelectedSource = z.object({
+  id: z.string().min(1).max(300),
+  cloudId: z.string().min(1).max(256),
+  siteName: z.string().min(1).max(512),
+  siteUrl: z.string().url(),
+  resourceId: z.string().min(1).max(256),
+  key: z.string().min(1).max(128),
+  name: z.string().min(1).max(512),
+  kind: AtlassianSourceKind,
+  destination: ConnectorDocumentDestination.optional(),
+  syncCadence: AtlassianSyncCadence,
+  syncEnabled: z.boolean(),
+  configGeneration: z.number().int().positive(),
+  readPolicy: AtlassianReadPolicy,
+  selectedAt: z.string().datetime(),
+});
+export type AtlassianSelectedSource = z.infer<typeof AtlassianSelectedSource>;
+
+export const AtlassianConnectionMetadata = z.object({
+  credentialRole: z.literal(ATLASSIAN_CREDENTIAL_ROLE),
+  credentialLabel: z.literal(ATLASSIAN_CREDENTIAL_LABEL),
+  atlassianAccountId: z.string().min(1).max(256),
+  displayName: z.string().min(1).max(512),
+  email: z.string().email().nullable().optional(),
+  sites: z
+    .array(
+      z.object({
+        cloudId: z.string().min(1).max(256),
+        name: z.string().min(1).max(512),
+        url: z.string().url(),
+        products: z.array(z.enum(["jira", "confluence"])).max(2),
+      }),
+    )
+    .min(1)
+    .max(50),
+  verifiedAt: z.string().datetime(),
+  accessMode: z.literal("readonly"),
+  lifecycle: AtlassianConnectionLifecycle.optional(),
+  documentDestination: ConnectorDocumentDestination.optional(),
+  selectedSources: z.array(AtlassianSelectedSource).max(100).default([]),
+});
+export type AtlassianConnectionMetadata = z.infer<typeof AtlassianConnectionMetadata>;
+
+export const AtlassianOAuthStartRequest = z.object({
+  connectionId: z.string().uuid().optional(),
+});
+export type AtlassianOAuthStartRequest = z.infer<typeof AtlassianOAuthStartRequest>;
+
+export const AtlassianOAuthStartResponse = z.object({
+  authorizationUrl: z.string().url(),
+  expiresAt: z.string().datetime(),
+});
+export type AtlassianOAuthStartResponse = z.infer<typeof AtlassianOAuthStartResponse>;
+
+export const AtlassianBrowseItem = z.object({
+  id: z.string().min(1).max(300),
+  cloudId: z.string().min(1).max(256),
+  siteName: z.string().min(1).max(512),
+  siteUrl: z.string().url(),
+  resourceId: z.string().min(1).max(256),
+  key: z.string().min(1).max(128),
+  name: z.string().min(1).max(512),
+  kind: AtlassianSourceKind,
+  description: z.string().max(2_000).nullable(),
+  webUrl: z.string().url(),
+});
+export type AtlassianBrowseItem = z.infer<typeof AtlassianBrowseItem>;
+
+export const AtlassianBrowseResponse = z.object({
+  connection: z.lazy(() => ConnectionMetadata),
+  items: z.array(AtlassianBrowseItem).max(200),
+});
+export type AtlassianBrowseResponse = z.infer<typeof AtlassianBrowseResponse>;
+
+export const SaveAtlassianSourcesRequest = z.object({
+  sources: z
+    .array(
+      AtlassianBrowseItem.pick({
+        id: true,
+        cloudId: true,
+        siteName: true,
+        siteUrl: true,
+        resourceId: true,
+        key: true,
+        name: true,
+        kind: true,
+      }),
+    )
+    .max(100),
+  destination: z.object({
+    authorityKind: z.enum(["organization", "workspace", "personal"]),
+    collectionId: z.string().uuid().nullable().default(null),
+  }),
+  syncCadence: AtlassianSyncCadence,
+  syncEnabled: z.boolean(),
+  readPolicy: AtlassianReadPolicy.default("allow"),
+});
+export type SaveAtlassianSourcesRequest = z.infer<typeof SaveAtlassianSourcesRequest>;
+
+export const AtlassianLifecycleActionRequest = z.object({
+  action: z.enum(["pause", "resume"]),
+  expectedVersion: z.number().int().positive(),
+});
+export type AtlassianLifecycleActionRequest = z.infer<typeof AtlassianLifecycleActionRequest>;
+
+export const AtlassianDisconnectRequest = z.object({
+  expectedVersion: z.number().int().positive(),
+  idempotencyKey: z.string().uuid(),
+});
+export type AtlassianDisconnectRequest = z.infer<typeof AtlassianDisconnectRequest>;
+
+export function atlassianScopesAllowRead(scopes: readonly string[]): boolean {
+  const granted = new Set(scopes);
+  return ATLASSIAN_REQUIRED_SCOPES.every((scope) => granted.has(scope));
+}

package/src/canonical-human-identities.ts

@@ -0,0 +1,93 @@
+import { z } from "zod";
+
+export const CanonicalHumanIdentityStatus = z.enum([
+  "active",
+  "recovery_required",
+  "disputed",
+  "disabled",
+]);
+export type CanonicalHumanIdentityStatus = z.infer<typeof CanonicalHumanIdentityStatus>;
+
+export const CanonicalHumanLoginBindingStatus = z.enum([
+  "active",
+  "recovery_pending",
+  "stale",
+  "disputed",
+  "revoked",
+]);
+export type CanonicalHumanLoginBindingStatus = z.infer<typeof CanonicalHumanLoginBindingStatus>;
+
+export const CanonicalHumanRecoveryState = z.enum([
+  "ready",
+  "recovery_required",
+  "lost_factor",
+  "disputed",
+  "disabled",
+]);
+export type CanonicalHumanRecoveryState = z.infer<typeof CanonicalHumanRecoveryState>;
+
+export const CanonicalHumanLoginBinding = z.object({
+  id: z.string().uuid(),
+  providerId: z.string().min(1).max(128),
+  providerAccountId: z.string().min(1).max(1024),
+  status: CanonicalHumanLoginBindingStatus,
+  revision: z.number().int().positive(),
+  verifiedAt: z.string().datetime(),
+  lastVerifiedAt: z.string().datetime(),
+  revokedAt: z.string().datetime().nullable(),
+  createdAt: z.string().datetime(),
+  updatedAt: z.string().datetime(),
+});
+export type CanonicalHumanLoginBinding = z.infer<typeof CanonicalHumanLoginBinding>;
+
+export const CanonicalHumanIdentityProjection = z.object({
+  activeIdentity: z.object({
+    id: z.string().uuid(),
+    displayName: z.string().min(1).max(256),
+    status: CanonicalHumanIdentityStatus,
+    identityRevision: z.number().int().positive(),
+    authRevision: z.number().int().positive(),
+    activeLoginBindingId: z.string().uuid().nullable(),
+    recoveryState: CanonicalHumanRecoveryState,
+    createdAt: z.string().datetime(),
+    updatedAt: z.string().datetime(),
+  }),
+  loginBindings: z.array(CanonicalHumanLoginBinding).max(64),
+});
+export type CanonicalHumanIdentityProjection = z.infer<typeof CanonicalHumanIdentityProjection>;
+
+const OperationFields = {
+  operationId: z.string().uuid().optional(),
+  expectedIdentityRevision: z.number().int().positive(),
+  reason: z.string().trim().min(1).max(512),
+} as const;
+
+export const LinkCanonicalHumanLoginBindingRequest = z.object({
+  ...OperationFields,
+  providerId: z.string().trim().min(1).max(128),
+  providerAccountId: z.string().trim().min(1).max(1024),
+});
+export type LinkCanonicalHumanLoginBindingRequest = z.infer<
+  typeof LinkCanonicalHumanLoginBindingRequest
+>;
+
+export const CanonicalHumanBindingOperationRequest = z.object({
+  ...OperationFields,
+});
+export type CanonicalHumanBindingOperationRequest = z.infer<
+  typeof CanonicalHumanBindingOperationRequest
+>;
+
+export const CanonicalHumanIdentityMutationOutcome = z.enum(["applied", "lost_factor", "disputed"]);
+export type CanonicalHumanIdentityMutationOutcome = z.infer<
+  typeof CanonicalHumanIdentityMutationOutcome
+>;
+
+export const CanonicalHumanIdentityMutationResponse = z.object({
+  outcome: CanonicalHumanIdentityMutationOutcome,
+  operationId: z.string().uuid(),
+  identity: CanonicalHumanIdentityProjection,
+});
+export type CanonicalHumanIdentityMutationResponse = z.infer<
+  typeof CanonicalHumanIdentityMutationResponse
+>;

package/src/codex-provider-account-authority.ts

@@ -0,0 +1,37 @@
+import { z } from "zod";
+
+const PositiveSafeInteger = z.number().int().positive().max(Number.MAX_SAFE_INTEGER);
+
+/**
+ * Opaque authority frozen at a Codex provider-account acceptance boundary.
+ *
+ * The snapshot deliberately carries no organization, membership, credential,
+ * provider-account, subject, label, quota, token, or plan identity. A later
+ * activation slice may use the user generation only together with separately
+ * authorized durable state; this value is never sufficient authority alone.
+ */
+export const CodexProviderAccountAuthoritySnapshotV1 = z.discriminatedUnion("scope", [
+  z
+    .object({
+      version: z.literal(1),
+      scope: z.literal("workspace"),
+    })
+    .strict(),
+  z
+    .object({
+      version: z.literal(1),
+      scope: z.literal("user"),
+      authorityGeneration: PositiveSafeInteger,
+    })
+    .strict(),
+]);
+
+export type CodexProviderAccountAuthoritySnapshotV1 = z.infer<
+  typeof CodexProviderAccountAuthoritySnapshotV1
+>;
+
+/** Explicit compatibility value for all pre-foundation accepted work. */
+export const LEGACY_WORKSPACE_CODEX_PROVIDER_ACCOUNT_AUTHORITY_SNAPSHOT_V1 = {
+  version: 1,
+  scope: "workspace",
+} as const satisfies CodexProviderAccountAuthoritySnapshotV1;