@opengeni/contracts 5.5.0 → 5.5.2-canary.40656248492001

package/dist/connector-destinations.js

@@ -7,7 +7,9 @@ import {
   connectorDocumentDestinationCollectionId,
   legacyWorkspaceConnectorDocumentDestination,
   resolveConnectorDocumentDestination
-} from "./chunk-WYBDERIY.js";
+} from "./chunk-RWEEUDHD.js";
+import "./chunk-AQYDZUJV.js";
+import "./chunk-56SNIMDO.js";
 export {
   ConnectorDocumentDestination,
   ConnectorDocumentDestinationAuthority,

package/dist/connector-tool-permissions.d.ts

@@ -20,7 +20,24 @@ export declare const ConnectorToolPermissionEntry: z.ZodObject<{
         block: "block";
     }>;
     inherited: z.ZodBoolean;
+    resetReason: z.ZodOptional<z.ZodLiteral<"operation_changed">>;
     approvalRequired: z.ZodBoolean;
+    source: z.ZodOptional<z.ZodEnum<{
+        action: "action";
+        conflict: "conflict";
+        connector_default: "connector_default";
+        recommended: "recommended";
+        tool: "tool";
+    }>>;
+    conditional: z.ZodOptional<z.ZodBoolean>;
+    actionPermissions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        actionName: z.ZodString;
+        permission: z.ZodEnum<{
+            allow: "allow";
+            ask: "ask";
+            block: "block";
+        }>;
+    }, z.core.$strip>>>;
 }, z.core.$strip>;
 export type ConnectorToolPermissionEntry = z.infer<typeof ConnectorToolPermissionEntry>;
 export declare const ConnectorToolPermissionsResponse: z.ZodObject<{
@@ -46,28 +63,75 @@ export declare const ConnectorToolPermissionsResponse: z.ZodObject<{
             block: "block";
         }>;
         inherited: z.ZodBoolean;
+        resetReason: z.ZodOptional<z.ZodLiteral<"operation_changed">>;
         approvalRequired: z.ZodBoolean;
+        source: z.ZodOptional<z.ZodEnum<{
+            action: "action";
+            conflict: "conflict";
+            connector_default: "connector_default";
+            recommended: "recommended";
+            tool: "tool";
+        }>>;
+        conditional: z.ZodOptional<z.ZodBoolean>;
+        actionPermissions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            actionName: z.ZodString;
+            permission: z.ZodEnum<{
+                allow: "allow";
+                ask: "ask";
+                block: "block";
+            }>;
+        }, z.core.$strip>>>;
     }, z.core.$strip>>;
     discoveryError: z.ZodNullable<z.ZodString>;
     canManage: z.ZodBoolean;
+    appliesTo: z.ZodOptional<z.ZodLiteral<"next_attempt">>;
+    revision: z.ZodOptional<z.ZodString>;
+    accountLabel: z.ZodOptional<z.ZodString>;
+    instanceKey: z.ZodOptional<z.ZodString>;
+    accounts: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        connectionId: z.ZodString;
+        label: z.ZodString;
+        scope: z.ZodEnum<{
+            none: "none";
+            personal: "personal";
+            workspace: "workspace";
+        }>;
+        instanceKey: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
 }, z.core.$strip>;
 export type ConnectorToolPermissionsResponse = z.infer<typeof ConnectorToolPermissionsResponse>;
 export declare const UpdateConnectorToolPermissionsRequest: z.ZodDiscriminatedUnion<[z.ZodObject<{
     connectionId: z.ZodString;
     target: z.ZodLiteral<"default">;
-    permission: z.ZodEnum<{
+    permission: z.ZodNullable<z.ZodEnum<{
         allow: "allow";
         ask: "ask";
         block: "block";
-    }>;
+    }>>;
+    expectedRevision: z.ZodOptional<z.ZodString>;
+    instanceKey: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>, z.ZodObject<{
     connectionId: z.ZodString;
     target: z.ZodLiteral<"tools">;
     toolNames: z.ZodArray<z.ZodString>;
-    permission: z.ZodEnum<{
+    permission: z.ZodNullable<z.ZodEnum<{
         allow: "allow";
         ask: "ask";
         block: "block";
-    }>;
+    }>>;
+    expectedRevision: z.ZodOptional<z.ZodString>;
+    instanceKey: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    connectionId: z.ZodString;
+    target: z.ZodLiteral<"action">;
+    toolName: z.ZodString;
+    actionName: z.ZodString;
+    permission: z.ZodNullable<z.ZodEnum<{
+        allow: "allow";
+        ask: "ask";
+        block: "block";
+    }>>;
+    expectedRevision: z.ZodOptional<z.ZodString>;
+    instanceKey: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>], "target">;
 export type UpdateConnectorToolPermissionsRequest = z.infer<typeof UpdateConnectorToolPermissionsRequest>;

package/dist/credential-profiles.d.ts

@@ -0,0 +1,166 @@
+/**
+ * Credential profiles: an opt-in mapping from environment variable names to
+ * secret references that Opengeni puts into the environment of every command
+ * an agent runs (exec_command, background commands, `run_on` exec), so CLIs
+ * such as `gh`, `git` and `az` find their credentials without the agent
+ * writing references into each command or a child's prompt.
+ *
+ * A workspace has at most one profile; a session can add its own entries,
+ * which its child sessions inherit (nearest session wins for a name). The
+ * references are resolved per command through the attempt's secret resolver,
+ * so vault policy, per-use approval and audit apply. Values exist only in
+ * the command's process environment, never on disk or in stored text.
+ *
+ * This module must not import runtime values from `./index` (the index
+ * re-exports it); only types cross that edge.
+ */
+import { z } from "zod";
+export declare const CREDENTIAL_PROFILE_LIMITS: {
+    readonly entriesMax: 32;
+    readonly nameMaxChars: 128;
+    readonly referenceMaxChars: 300;
+};
+/**
+ * Names reserved for Opengeni itself (per-command secret bindings, the
+ * Codemode bearer and similar). A profile cannot set them.
+ */
+export declare const CREDENTIAL_PROFILE_RESERVED_PREFIX = "OPENGENI_";
+/** True for a portable environment variable name a profile may set. */
+export declare function isCredentialProfileEnvName(name: string): boolean;
+/**
+ * Accept a reference written escaped (a leading backslash), as agents are
+ * taught to write references they hand on, and store it unescaped. Profile
+ * tools never resolve references, so both forms mean the same reference.
+ */
+export declare function normalizeCredentialProfileReference(reference: string): string;
+export declare const CredentialProfileEntry: z.ZodObject<{
+    name: z.ZodString;
+    reference: z.ZodString;
+}, z.core.$strict>;
+export type CredentialProfileEntry = z.infer<typeof CredentialProfileEntry>;
+/** The body of a profile at one level (workspace or session). */
+export declare const CredentialProfileInput: z.ZodObject<{
+    entries: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        reference: z.ZodString;
+    }, z.core.$strict>>;
+    gitHelper: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+}, z.core.$strict>;
+export type CredentialProfileInput = z.infer<typeof CredentialProfileInput>;
+export declare const CredentialProfileScope: z.ZodEnum<{
+    session: "session";
+    workspace: "workspace";
+}>;
+export type CredentialProfileScope = z.infer<typeof CredentialProfileScope>;
+export declare const CredentialProfileView: z.ZodObject<{
+    scope: z.ZodEnum<{
+        session: "session";
+        workspace: "workspace";
+    }>;
+    sessionId: z.ZodNullable<z.ZodString>;
+    entries: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        reference: z.ZodString;
+    }, z.core.$strict>>;
+    gitHelper: z.ZodNullable<z.ZodBoolean>;
+    updatedAt: z.ZodString;
+    updatedBySubjectId: z.ZodString;
+}, z.core.$strip>;
+export type CredentialProfileView = z.infer<typeof CredentialProfileView>;
+export declare const EffectiveCredentialProfileEntry: z.ZodObject<{
+    name: z.ZodString;
+    reference: z.ZodString;
+    source: z.ZodObject<{
+        scope: z.ZodEnum<{
+            session: "session";
+            workspace: "workspace";
+        }>;
+        sessionId: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strict>;
+export type EffectiveCredentialProfileEntry = z.infer<typeof EffectiveCredentialProfileEntry>;
+/** What a session's commands receive: workspace entries, then each session from the root down. */
+export declare const EffectiveCredentialProfile: z.ZodObject<{
+    entries: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        reference: z.ZodString;
+        source: z.ZodObject<{
+            scope: z.ZodEnum<{
+                session: "session";
+                workspace: "workspace";
+            }>;
+            sessionId: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>;
+    }, z.core.$strict>>;
+    gitHelper: z.ZodBoolean;
+}, z.core.$strip>;
+export type EffectiveCredentialProfile = z.infer<typeof EffectiveCredentialProfile>;
+export declare const WorkspaceCredentialProfileResponse: z.ZodObject<{
+    profile: z.ZodNullable<z.ZodObject<{
+        scope: z.ZodEnum<{
+            session: "session";
+            workspace: "workspace";
+        }>;
+        sessionId: z.ZodNullable<z.ZodString>;
+        entries: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            reference: z.ZodString;
+        }, z.core.$strict>>;
+        gitHelper: z.ZodNullable<z.ZodBoolean>;
+        updatedAt: z.ZodString;
+        updatedBySubjectId: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type WorkspaceCredentialProfileResponse = z.infer<typeof WorkspaceCredentialProfileResponse>;
+export declare const SessionCredentialProfileResponse: z.ZodObject<{
+    profile: z.ZodNullable<z.ZodObject<{
+        scope: z.ZodEnum<{
+            session: "session";
+            workspace: "workspace";
+        }>;
+        sessionId: z.ZodNullable<z.ZodString>;
+        entries: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            reference: z.ZodString;
+        }, z.core.$strict>>;
+        gitHelper: z.ZodNullable<z.ZodBoolean>;
+        updatedAt: z.ZodString;
+        updatedBySubjectId: z.ZodString;
+    }, z.core.$strip>>;
+    effective: z.ZodObject<{
+        entries: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            reference: z.ZodString;
+            source: z.ZodObject<{
+                scope: z.ZodEnum<{
+                    session: "session";
+                    workspace: "workspace";
+                }>;
+                sessionId: z.ZodNullable<z.ZodString>;
+            }, z.core.$strip>;
+        }, z.core.$strict>>;
+        gitHelper: z.ZodBoolean;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type SessionCredentialProfileResponse = z.infer<typeof SessionCredentialProfileResponse>;
+export declare const CREDENTIAL_PROFILE_TOOL_NAMES: readonly ["secret_profile_get", "secret_profile_set"];
+export type CredentialProfileToolName = (typeof CREDENTIAL_PROFILE_TOOL_NAMES)[number];
+export declare const SecretProfileGetInput: z.ZodObject<{
+    scope: z.ZodOptional<z.ZodEnum<{
+        session: "session";
+        workspace: "workspace";
+    }>>;
+}, z.core.$strict>;
+export type SecretProfileGetInput = z.infer<typeof SecretProfileGetInput>;
+export declare const SecretProfileSetInput: z.ZodObject<{
+    scope: z.ZodOptional<z.ZodEnum<{
+        session: "session";
+        workspace: "workspace";
+    }>>;
+    entries: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        reference: z.ZodString;
+    }, z.core.$strict>>;
+    gitHelper: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+}, z.core.$strict>;
+export type SecretProfileSetInput = z.infer<typeof SecretProfileSetInput>;

package/dist/cua-desktop-tools.d.ts

@@ -0,0 +1,19 @@
+/** Generated from the bundled CUA worker's listToolsJson(). Never from a live desktop. */
+export type CuaDesktopTool = {
+    name: string;
+    description: string;
+    inputSchema: Record<string, unknown>;
+    outputSchema?: Record<string, unknown>;
+    annotations: Record<string, boolean>;
+    capabilities: string[];
+};
+export declare const CUA_DESKTOP_TOOLS: readonly CuaDesktopTool[];
+export declare const CUA_LINUX_DESKTOP_TOOLS: readonly CuaDesktopTool[];
+/** Windows publishes its own input schemas and omits tools it does not implement. */
+export declare const CUA_WINDOWS_DESKTOP_TOOLS: readonly CuaDesktopTool[];
+/** The CUA release each platform's catalog was generated from. */
+export declare const CUA_DESKTOP_TOOL_VERSIONS: Readonly<Record<"macos" | "linux" | "windows", string>>;
+export declare function cuaDesktopToolsFor(platform: "macos" | "windows" | "linux"): readonly CuaDesktopTool[];
+/** Keep platform contracts intact; the session's worker enforces its own variant. */
+export declare function cuaDesktopToolVariants(name: string): readonly CuaDesktopTool[];
+export declare function isCuaDesktopModelTool(name: string | null): boolean;

package/dist/define-schema.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Construct a schema eagerly, but give bundlers one removable boundary around
+ * the whole initializer (including nested schemas and chained builders).
+ * Annotate calls with @__PURE__ only when the factory has no effects beyond
+ * constructing its returned schema. This is not lazy validation: used schemas
+ * are created once, in the same module evaluation order as ordinary constants.
+ */
+export declare function defineSchema<Schema>(factory: () => Schema): Schema;

package/dist/desktop-app.d.ts

@@ -0,0 +1,28 @@
+/**
+ * The web console running inside an Opengeni desktop app.
+ *
+ * A sign-in the console starts there finishes in the person's own browser
+ * (providers refuse embedded app windows). The console marks its API requests
+ * with this header so a flow that ends in that browser can hand the person
+ * back to the app instead of leaving them on a web page. It only changes where
+ * the person's own browser goes afterwards; it never grants or narrows access.
+ */
+export declare const OPENGENI_DESKTOP_APP_HEADER = "x-opengeni-desktop-app";
+/** The console page that hands a finished browser flow back to the desktop app. */
+export declare const DESKTOP_APP_RETURN_PATH = "/desktop-return";
+/**
+ * Where a flow started in the desktop app should send the browser when it
+ * finishes: the console's hand-back page carrying the original destination.
+ * Only a destination on the requesting console's own origin is wrapped;
+ * anything else (an embedding product's page, a malformed origin) is returned
+ * unchanged, as is a destination that is already the hand-back page.
+ */
+export declare function desktopAppReturnUrl(returnUrl: string, consoleOrigin: string | null): string;
+/**
+ * The same hand-back for flows that name their destination as a console path
+ * (`/workspaces/…`) and add their outcome parameters to it when they finish;
+ * the hand-back page carries those parameters on to the destination. A path
+ * that is not console-relative, or is already the hand-back page, is returned
+ * unchanged.
+ */
+export declare function desktopAppReturnPath(returnPath: string): string;

package/dist/direct-model-provider.d.ts

@@ -0,0 +1,38 @@
+import { z } from "zod";
+export declare const DirectModelProvider: z.ZodEnum<{
+    azure_openai: "azure_openai";
+    openai: "openai";
+}>;
+export type DirectModelProvider = z.infer<typeof DirectModelProvider>;
+/** Pin customer credentials to official provider origins, never arbitrary URLs. */
+export declare const AzureOpenAIEndpoint: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+/** An exact OpenAI model or Azure OpenAI deployment name. */
+export declare const DirectModelName: z.ZodString;
+export declare const DirectModelProviderMetadata: z.ZodObject<{
+    provider: z.ZodEnum<{
+        azure_openai: "azure_openai";
+        openai: "openai";
+    }>;
+    model: z.ZodString;
+    endpoint: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+}, z.core.$strict>;
+export type DirectModelProviderMetadata = z.infer<typeof DirectModelProviderMetadata>;
+export declare function directModelConnectionSpec(connection: {
+    id: string;
+    version: number;
+    subjectId: string | null;
+    kind: string;
+    status: string;
+    providerDomain: string;
+    metadata: Record<string, unknown>;
+}): {
+    provider: "azure_openai" | "openai";
+    model: string;
+    endpoint?: string | undefined;
+    baseUrl: string;
+    providerId: string;
+    modelId: string;
+    connectionId: string;
+    version: number;
+} | null;
+export declare function isDirectModelId(modelId: string): boolean;

package/dist/document-artifact-commands.js

@@ -23,8 +23,8 @@ import {
   encodeDocumentArtifactCommandBatch,
   encodeDocumentArtifactQuery,
   encodeDocumentArtifactQueryResponse
-} from "./chunk-RIY7GYQS.js";
-import "./chunk-MYBZRDTY.js";
+} from "./chunk-PTSROVDG.js";
+import "./chunk-WQI7VNN4.js";
 export {
   DOCUMENT_ARTIFACT_COMMAND_MAX_BYTES,
   DOCUMENT_ARTIFACT_COMMAND_MAX_COMMANDS,

package/dist/document-artifact-query.js

@@ -23,8 +23,8 @@ import {
   encodeDocumentArtifactCommandBatch,
   encodeDocumentArtifactQuery,
   encodeDocumentArtifactQueryResponse
-} from "./chunk-RIY7GYQS.js";
-import "./chunk-MYBZRDTY.js";
+} from "./chunk-PTSROVDG.js";
+import "./chunk-WQI7VNN4.js";
 export {
   DOCUMENT_ARTIFACT_COMMAND_MAX_BYTES,
   DOCUMENT_ARTIFACT_COMMAND_MAX_COMMANDS,

package/dist/editable-artifact-binary.d.ts

@@ -8,6 +8,13 @@ export declare function positiveSafeInteger(value: number, label: string): numbe
 export declare function nonnegativeSafeInteger(value: number, label: string): number;
 export declare function boundedU32(value: number, label: string, maximum?: number): number;
 export declare function canonicalNumber(value: number, label: string): number;
+/**
+ * FNV-1a-64 over `bytes[0, end)` using 32-bit integer limbs, with the low
+ * limb's product split into 16-bit halves so every step stays in int32
+ * arithmetic. Bit-identical to the BigInt definition without allocating a
+ * BigInt per byte (which made checksumming stored history a dominant CPU cost).
+ */
+export declare function fnv1a64Limbs(bytes: Uint8Array, end?: number): readonly [low: number, high: number];
 export declare function fnv1a64(bytes: Uint8Array): bigint;
 export declare function equalBytes(left: Uint8Array, right: Uint8Array): boolean;
 export declare class ArtifactBinaryWriter {

package/dist/editable-artifact-causal-frontier.js

@@ -5,8 +5,8 @@ import {
   assertCanonicalEditableArtifactCausalFrontierBytes,
   decodeEditableArtifactCausalFrontier,
   encodeEditableArtifactCausalFrontier
-} from "./chunk-YRKRZ6OF.js";
-import "./chunk-MYBZRDTY.js";
+} from "./chunk-TOOJIBJC.js";
+import "./chunk-WQI7VNN4.js";
 export {
   EDITABLE_ARTIFACT_CAUSAL_FRONTIER_MAX_BYTES,
   EDITABLE_ARTIFACT_CAUSAL_FRONTIER_MAX_REPLICAS,

package/dist/editable-artifact-codec-registry.js

@@ -2,12 +2,10 @@ import {
   EDITABLE_ARTIFACT_CODEC_REGISTRY,
   currentEditableArtifactCompatibility,
   editableArtifactCodecFor
-} from "./chunk-SIOU2K4U.js";
-import "./chunk-RIY7GYQS.js";
-import "./chunk-D2HKF2EF.js";
-import "./chunk-MYBZRDTY.js";
-import "./chunk-Y3KNXVTD.js";
-import "./chunk-TXTQIYCV.js";
+} from "./chunk-LJH2EYGT.js";
+import "./chunk-PTSROVDG.js";
+import "./chunk-W3NBPR4E.js";
+import "./chunk-RUQ4I6DO.js";
 import {
   DOCUMENT_ARTIFACT_MODEL_SCHEMA_VERSION,
   DOCUMENT_ARTIFACT_SNAPSHOT_VERSION,
@@ -15,7 +13,9 @@ import {
   PRESENTATION_ARTIFACT_SNAPSHOT_VERSION,
   SPREADSHEET_ARTIFACT_MODEL_SCHEMA_VERSION,
   SPREADSHEET_COLLABORATION_SNAPSHOT_VERSION
-} from "./chunk-PX3VCKAU.js";
+} from "./chunk-WVCFSOUZ.js";
+import "./chunk-XP5M3IKT.js";
+import "./chunk-WQI7VNN4.js";
 export {
   DOCUMENT_ARTIFACT_MODEL_SCHEMA_VERSION,
   DOCUMENT_ARTIFACT_SNAPSHOT_VERSION,

package/dist/editable-artifact-committed-transaction.js

@@ -4,10 +4,12 @@ import {
   MAX_COMMITTED_TRANSACTION_CELLS,
   MAX_COMMITTED_TRANSACTION_OPERATIONS,
   decodeCommittedTransactionSummary
-} from "./chunk-3SIZGL3O.js";
+} from "./chunk-ZYVEJFNU.js";
+import "./chunk-RUQ4I6DO.js";
 import {
   COMMITTED_TRANSACTION_PROTOCOL_VERSION
-} from "./chunk-PX3VCKAU.js";
+} from "./chunk-WVCFSOUZ.js";
+import "./chunk-WQI7VNN4.js";
 export {
   COMMITTED_TRANSACTION_PROTOCOL_VERSION,
   MAX_COMMITTED_TRANSACTION_BYTES,

package/dist/editable-artifact-live.js

@@ -2,16 +2,16 @@ import {
   EDITABLE_ARTIFACT_INTENT_MAX_BYTES,
   hashEditableArtifactMutationIntentBytes
 } from "./chunk-NVJMJWLL.js";
-import "./chunk-SIOU2K4U.js";
-import "./chunk-YRKRZ6OF.js";
-import "./chunk-RIY7GYQS.js";
-import "./chunk-D2HKF2EF.js";
-import "./chunk-MYBZRDTY.js";
-import "./chunk-Y3KNXVTD.js";
-import "./chunk-TXTQIYCV.js";
+import "./chunk-TOOJIBJC.js";
+import "./chunk-LJH2EYGT.js";
+import "./chunk-PTSROVDG.js";
+import "./chunk-W3NBPR4E.js";
+import "./chunk-RUQ4I6DO.js";
 import {
   EDITABLE_ARTIFACT_LIVE_WIRE_VERSION
-} from "./chunk-PX3VCKAU.js";
+} from "./chunk-WVCFSOUZ.js";
+import "./chunk-XP5M3IKT.js";
+import "./chunk-WQI7VNN4.js";
 
 // src/editable-artifact-live.ts
 var MAGIC = new TextEncoder().encode("OGALV002");

package/dist/editable-artifact-serialized-commit.js

@@ -4,18 +4,18 @@ import {
   assertCanonicalEditableArtifactSerializedCommit,
   decodeEditableArtifactSerializedCommit,
   encodeEditableArtifactSerializedCommit
-} from "./chunk-NRMCVHAU.js";
+} from "./chunk-WMGO4HJU.js";
 import "./chunk-NVJMJWLL.js";
-import "./chunk-SIOU2K4U.js";
-import "./chunk-YRKRZ6OF.js";
-import "./chunk-RIY7GYQS.js";
-import "./chunk-D2HKF2EF.js";
-import "./chunk-MYBZRDTY.js";
-import "./chunk-Y3KNXVTD.js";
-import "./chunk-TXTQIYCV.js";
+import "./chunk-TOOJIBJC.js";
+import "./chunk-LJH2EYGT.js";
+import "./chunk-PTSROVDG.js";
+import "./chunk-W3NBPR4E.js";
+import "./chunk-RUQ4I6DO.js";
 import {
   EDITABLE_ARTIFACT_SERIALIZED_COMMIT_VERSION
-} from "./chunk-PX3VCKAU.js";
+} from "./chunk-WVCFSOUZ.js";
+import "./chunk-XP5M3IKT.js";
+import "./chunk-WQI7VNN4.js";
 export {
   EDITABLE_ARTIFACT_NATIVE_RECEIPT_MAX_BYTES,
   EDITABLE_ARTIFACT_SERIALIZED_COMMIT_MAX_BYTES,

package/dist/editable-artifact-versions.d.ts

@@ -1,4 +1,10 @@
-/** Modality-specific durable semantic/schema versions. */
+/**
+ * Modality-specific durable semantic/schema versions.
+ * Spreadsheet dimensions are an additive current-schema extension: existing
+ * command/operation tags and dimension-free snapshot bytes stay unchanged.
+ * Direct snapshots and private projections advertise their explicit extension
+ * flags; old executables reject new tags/flags, never silently discard them.
+ */
 export declare const SPREADSHEET_ARTIFACT_MODEL_SCHEMA_VERSION: 2;
 export declare const DOCUMENT_ARTIFACT_MODEL_SCHEMA_VERSION: 1;
 export declare const PRESENTATION_ARTIFACT_MODEL_SCHEMA_VERSION: 1;

package/dist/editable-artifact-versions.js

@@ -11,7 +11,7 @@ import {
   SPREADSHEET_COLLABORATION_SNAPSHOT_VERSION,
   SPREADSHEET_KERNEL_COMMAND_VERSION,
   SPREADSHEET_KERNEL_SNAPSHOT_VERSION
-} from "./chunk-PX3VCKAU.js";
+} from "./chunk-WVCFSOUZ.js";
 export {
   COMMITTED_TRANSACTION_PROTOCOL_VERSION,
   DOCUMENT_ARTIFACT_MODEL_SCHEMA_VERSION,