@sequenceholdings/artifact-studio 0.6.4 → 0.6.7

package/dist/manifest-next-ingress.d.ts

@@ -58,6 +58,7 @@ export declare const artifactNextExternalIngressSchema: z.ZodObject<{
         data: z.ZodPrefault<z.ZodObject<{
             read: z.ZodDefault<z.ZodArray<z.ZodString>>;
             write: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            operations: z.ZodDefault<z.ZodArray<z.ZodString>>;
         }, z.core.$strict>>;
         api: z.ZodPrefault<z.ZodObject<{
             read: z.ZodDefault<z.ZodArray<z.ZodString>>;
@@ -123,6 +124,7 @@ export declare const artifactNextIngressSchema: z.ZodObject<{
             data: z.ZodPrefault<z.ZodObject<{
                 read: z.ZodDefault<z.ZodArray<z.ZodString>>;
                 write: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                operations: z.ZodDefault<z.ZodArray<z.ZodString>>;
             }, z.core.$strict>>;
             api: z.ZodPrefault<z.ZodObject<{
                 read: z.ZodDefault<z.ZodArray<z.ZodString>>;
@@ -203,8 +205,9 @@ interface ServerForIngress {
 /**
  * Cross-field rules between `server.ingress` and the rest of `server`: one ingress per provider,
  * a service account distinct from the app's, capabilities inside the server's own (verbatim list
- * membership; for storage, the same workspace at a role no higher than the server's), and room for
- * the ingress share of concurrency. Called from the server schema's refinement.
+ * membership; for storage, the same workspace at a role no higher than the server's; for
+ * `data.operations`, a namespace the ingress's own data reaches), and room for the ingress share of
+ * concurrency. Called from the server schema's refinement.
  */
 export declare function validateIngressAgainstServer({ server, ctx }: {
     server: ServerForIngress;

package/dist/manifest-next-ingress.js

@@ -62,11 +62,17 @@ const evidenceEntrySchema = z.strictObject({
 // external caller run any mutation the ORM role allows over that table, and evidence binding and
 // freshness are keyed per named operation (D28; design C-3, "by name, no globs").
 const ingressDataWriteRef = boundedRef.refine((ref) => ormOperationRef.test(ref), 'Ingress ORM writes name each operation: namespace/ops/Operation');
+// The ingress service account holds grants that span every row its role reaches, so an external
+// caller runs only the ORM operations its ingress names: these (reads) and `write`. The broker
+// refuses any other persisted operation, query or mutation, before the data plane's table check
+// (design §(g.3), "Operation allow-list"). By name, no globs, like `write`.
+const ingressDataOperationRef = boundedRef.refine((ref) => ormOperationRef.test(ref), 'Ingress ORM operations name each operation: namespace/ops/Operation');
 const ingressCapabilitiesSchema = z.strictObject({
     storage: storageScopesSchema.optional(),
     data: z.strictObject({
         read: z.array(dataReadRef).max(256).default([]),
         write: z.array(ingressDataWriteRef).max(256).default([]),
+        operations: z.array(ingressDataOperationRef).max(256).refine(unique, 'Ingress ORM operations must be unique').default([]),
     }).prefault({}),
     api: reachShape.api,
     functions: reachShape.functions,
@@ -130,11 +136,29 @@ function requireMembers({ ctx, path, entries, allowed, label }) {
             ctx.addIssue({ code: 'custom', path: [...path, index], message: `${entry} must also be declared in server.capabilities.${label}` });
     }
 }
+/**
+ * An ingress operation ref names its namespace, and the ingress's own data capabilities (read or
+ * write) must reach it: an external caller's grant is built from those, so an operation in any other
+ * namespace could never run (the grant refuses its namespace before the allow-list is consulted).
+ * The ingress's read and write already sit inside the server's, so this also keeps the namespace
+ * inside the server's data. The operation itself need not be listed anywhere else: the data plane
+ * still checks its tables against the grant.
+ */
+function requireReachedNamespaces({ ctx, path, entries, reached }) {
+    const namespaces = new Set([...reached.read, ...reached.write].map((ref) => ref.split('/', 1)[0]));
+    for (const [index, entry] of entries.entries()) {
+        const namespace = entry.split('/', 1)[0];
+        if (!namespaces.has(namespace)) {
+            ctx.addIssue({ code: 'custom', path: [...path, index], message: `${entry} names namespace ${namespace}, which this ingress's capabilities.data does not reach` });
+        }
+    }
+}
 /**
  * Cross-field rules between `server.ingress` and the rest of `server`: one ingress per provider,
  * a service account distinct from the app's, capabilities inside the server's own (verbatim list
- * membership; for storage, the same workspace at a role no higher than the server's), and room for
- * the ingress share of concurrency. Called from the server schema's refinement.
+ * membership; for storage, the same workspace at a role no higher than the server's; for
+ * `data.operations`, a namespace the ingress's own data reaches), and room for the ingress share of
+ * concurrency. Called from the server schema's refinement.
  */
 export function validateIngressAgainstServer({ server, ctx }) {
     const external = server.ingress?.external;
@@ -171,6 +195,7 @@ export function validateIngressAgainstServer({ server, ctx }) {
         const capabilities = [...at, 'capabilities'];
         requireMembers({ ctx, path: [...capabilities, 'data', 'read'], entries: own.data.read, allowed: declared.data.read, label: 'data.read' });
         requireMembers({ ctx, path: [...capabilities, 'data', 'write'], entries: own.data.write, allowed: declared.data.write, label: 'data.write' });
+        requireReachedNamespaces({ ctx, path: [...capabilities, 'data', 'operations'], entries: own.data.operations, reached: own.data });
         requireMembers({ ctx, path: [...capabilities, 'api', 'read'], entries: own.api.read, allowed: declared.api.read, label: 'api.read' });
         requireMembers({ ctx, path: [...capabilities, 'api', 'write'], entries: own.api.write, allowed: declared.api.write, label: 'api.write' });
         requireMembers({ ctx, path: [...capabilities, 'functions', 'invoke'], entries: own.functions.invoke, allowed: declared.functions.invoke, label: 'functions.invoke' });

package/dist/manifest-next.d.ts

@@ -22,6 +22,7 @@ export declare const ARTIFACT_NEXT_RESOURCE_DEFAULTS: {
     timeout_seconds: number;
 };
 export { artifactNextAuditCapabilitySchema };
+export type { ArtifactNextBrowserData } from './manifest-next-browser-data.js';
 export * from './manifest-next-ingress.js';
 export declare const artifactNextServerCapabilitiesSchema: z.ZodPrefault<z.ZodObject<{
     audit: z.ZodOptional<z.ZodObject<{
@@ -59,11 +60,15 @@ export declare const artifactNextResourceLimitsSchema: z.ZodPrefault<z.ZodObject
     timeout_seconds: z.ZodDefault<z.ZodNumber>;
 }, z.core.$strict>>;
 export declare const artifactNextSecretNameSchema: z.ZodString;
-export declare const artifactNextSecretBindingSchema: z.ZodObject<{
+export declare const artifactNextSecretBindingSchema: z.ZodUnion<readonly [z.ZodObject<{
     name: z.ZodString;
     secret_id: z.ZodUUID;
     version: z.ZodNumber;
-}, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    name: z.ZodString;
+    secret_name: z.ZodString;
+    version: z.ZodNumber;
+}, z.core.$strict>]>;
 /** Pinned public assets fetched by the trusted preparation stage before offline compilation. */
 export declare const artifactNextPublicFontSchema: z.ZodObject<{
     path: z.ZodString;
@@ -107,11 +112,15 @@ export declare const artifactNextServerSchema: z.ZodPrefault<z.ZodObject<{
         }, z.core.$strict>>;
     }, z.core.$strict>>;
     service_account: z.ZodOptional<z.ZodString>;
-    secrets: z.ZodDefault<z.ZodArray<z.ZodObject<{
+    secrets: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
         name: z.ZodString;
         secret_id: z.ZodUUID;
         version: z.ZodNumber;
-    }, z.core.$strict>>>;
+    }, z.core.$strict>, z.ZodObject<{
+        name: z.ZodString;
+        secret_name: z.ZodString;
+        version: z.ZodNumber;
+    }, z.core.$strict>]>>>;
     egress: z.ZodDefault<z.ZodArray<z.ZodString>>;
     resources: z.ZodPrefault<z.ZodObject<{
         cpu: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<4>, z.ZodLiteral<8>]>>;
@@ -142,6 +151,7 @@ export declare const artifactNextServerSchema: z.ZodPrefault<z.ZodObject<{
                 data: z.ZodPrefault<z.ZodObject<{
                     read: z.ZodDefault<z.ZodArray<z.ZodString>>;
                     write: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                    operations: z.ZodDefault<z.ZodArray<z.ZodString>>;
                 }, z.core.$strict>>;
                 api: z.ZodPrefault<z.ZodObject<{
                     read: z.ZodDefault<z.ZodArray<z.ZodString>>;
@@ -219,6 +229,12 @@ export declare const artifactStudioNextManifestSchema: z.ZodObject<{
         next: z.ZodDefault<z.ZodLiteral<"16.3">>;
     }, z.core.$strict>>;
     capabilities: z.ZodPrefault<z.ZodObject<{
+        data: z.ZodPrefault<z.ZodObject<{
+            operations: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            required_capabilities: z.ZodOptional<z.ZodPreprocess<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>>;
+            read: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            write: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>>;
         allow_downloads: z.ZodDefault<z.ZodBoolean>;
         allow_popups: z.ZodDefault<z.ZodBoolean>;
         roles: z.ZodOptional<z.ZodObject<{
@@ -238,10 +254,6 @@ export declare const artifactStudioNextManifestSchema: z.ZodObject<{
             editor: "editor";
             admin: "admin";
         }>>>;
-        data: z.ZodPrefault<z.ZodObject<{
-            read: z.ZodDefault<z.ZodArray<z.ZodString>>;
-            write: z.ZodDefault<z.ZodArray<z.ZodString>>;
-        }, z.core.$strict>>;
         api: z.ZodPrefault<z.ZodObject<{
             read: z.ZodDefault<z.ZodArray<z.ZodString>>;
             write: z.ZodDefault<z.ZodArray<z.ZodString>>;
@@ -291,11 +303,15 @@ export declare const artifactStudioNextManifestSchema: z.ZodObject<{
             }, z.core.$strict>>;
         }, z.core.$strict>>;
         service_account: z.ZodOptional<z.ZodString>;
-        secrets: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        secrets: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
             name: z.ZodString;
             secret_id: z.ZodUUID;
             version: z.ZodNumber;
-        }, z.core.$strict>>>;
+        }, z.core.$strict>, z.ZodObject<{
+            name: z.ZodString;
+            secret_name: z.ZodString;
+            version: z.ZodNumber;
+        }, z.core.$strict>]>>>;
         egress: z.ZodDefault<z.ZodArray<z.ZodString>>;
         resources: z.ZodPrefault<z.ZodObject<{
             cpu: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<4>, z.ZodLiteral<8>]>>;
@@ -326,6 +342,7 @@ export declare const artifactStudioNextManifestSchema: z.ZodObject<{
                     data: z.ZodPrefault<z.ZodObject<{
                         read: z.ZodDefault<z.ZodArray<z.ZodString>>;
                         write: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                        operations: z.ZodDefault<z.ZodArray<z.ZodString>>;
                     }, z.core.$strict>>;
                     api: z.ZodPrefault<z.ZodObject<{
                         read: z.ZodDefault<z.ZodArray<z.ZodString>>;

package/dist/manifest-next.js

@@ -1,6 +1,7 @@
 import { ontologyContractSchema } from '@sequenceholdings/orm/canonical';
 import { z } from 'zod';
 import { capabilityPinsSchema, customRolesBlockSchema, validateCapabilityPins } from './manifest-custom-roles.js';
+import { artifactNextBrowserDataSchema, validateBrowserDataAdmission } from './manifest-next-browser-data.js';
 import { isManagedServerInvokePath } from './server/managed-server-path.js';
 import { artifactNextIngressSchema, validateIngressAgainstServer } from './manifest-next-ingress.js';
 import { artifactNextAuditCapabilitySchema, reachShape, serviceAccountRef } from './manifest-next-reach.js';
@@ -25,6 +26,7 @@ const strictCustomRoles = customRolesBlockSchema.safeExtend({
 }).strict();
 const browserCapabilities = z.strictObject({
     ...reachShape,
+    data: artifactNextBrowserDataSchema,
     allow_downloads: z.boolean().default(false),
     allow_popups: z.boolean().default(false),
     roles: strictCustomRoles.optional(),
@@ -47,11 +49,19 @@ export const artifactNextResourceLimitsSchema = z.strictObject({
 const envName = z.string().max(128).regex(/^[A-Z][A-Z0-9_]*$/);
 const reservedServerEnv = /^(NEXT_PUBLIC_|ARTIFACT_|SEQUENCE_|GOOGLE_|GCP_|GCLOUD_|DOPPLER_|MODAL_|AUTH0_|NPM_CONFIG_|npm_config_)/;
 export const artifactNextSecretNameSchema = envName.refine((name) => !reservedServerEnv.test(name) && !['NODE_OPTIONS', 'NODE_ENV', 'PORT', 'HOSTNAME', 'PATH', 'HOME', 'LD_PRELOAD', 'LD_LIBRARY_PATH'].includes(name), 'Secret names cannot override platform/runtime environment variables or expose NEXT_PUBLIC_ values');
-export const artifactNextSecretBindingSchema = z.strictObject({
-    name: artifactNextSecretNameSchema,
-    secret_id: z.uuid(),
-    version: z.number().int().positive(),
-});
+export const artifactNextSecretBindingSchema = z.union([
+    z.strictObject({
+        name: artifactNextSecretNameSchema,
+        secret_id: z.uuid(),
+        version: z.number().int().positive(),
+    }),
+    z.strictObject({
+        name: artifactNextSecretNameSchema,
+        // A registry name can differ from the mounted env name, including its reserved prefixes.
+        secret_name: z.string().max(255).regex(/^[A-Z][A-Z0-9_]*$/),
+        version: z.number().int().positive(),
+    }),
+]);
 const publicEnvironmentName = envName.refine((name) => name.startsWith('NEXT_PUBLIC_') && !/(^|_)(SECRET|TOKEN|PASSWORD|CREDENTIALS?|PRIVATE_KEY|API_KEY)(_|$)/.test(name), 'Public build variables require NEXT_PUBLIC_ and must not contain secret, token, password, credential, or private/API key names');
 /** Pinned public assets fetched by the trusted preparation stage before offline compilation. */
 export const artifactNextPublicFontSchema = z.strictObject({
@@ -117,6 +127,7 @@ export const artifactStudioNextManifestSchema = z.strictObject({
     sidebarIcon: z.string().max(64).optional(),
     sidebarBadge: sidebarBadgeSchema.strict().optional(),
 }).superRefine((manifest, ctx) => {
+    validateBrowserDataAdmission({ ...manifest.capabilities, ctx });
     for (const message of validateCapabilityPins({ uses: manifest.capabilities.uses, roles: manifest.capabilities.roles })) {
         ctx.addIssue({ code: 'custom', path: ['capabilities', 'uses'], message });
     }

package/dist/manifest.d.ts

@@ -112,6 +112,12 @@ export declare const artifactStudioManifestSchema: z.ZodUnion<readonly [z.ZodObj
         next: z.ZodDefault<z.ZodLiteral<"16.3">>;
     }, z.core.$strict>>;
     capabilities: z.ZodPrefault<z.ZodObject<{
+        data: z.ZodPrefault<z.ZodObject<{
+            operations: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            required_capabilities: z.ZodOptional<z.ZodPreprocess<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>>;
+            read: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            write: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>>;
         allow_downloads: z.ZodDefault<z.ZodBoolean>;
         allow_popups: z.ZodDefault<z.ZodBoolean>;
         roles: z.ZodOptional<z.ZodObject<{
@@ -131,10 +137,6 @@ export declare const artifactStudioManifestSchema: z.ZodUnion<readonly [z.ZodObj
             editor: "editor";
             admin: "admin";
         }>>>;
-        data: z.ZodPrefault<z.ZodObject<{
-            read: z.ZodDefault<z.ZodArray<z.ZodString>>;
-            write: z.ZodDefault<z.ZodArray<z.ZodString>>;
-        }, z.core.$strict>>;
         api: z.ZodPrefault<z.ZodObject<{
             read: z.ZodDefault<z.ZodArray<z.ZodString>>;
             write: z.ZodDefault<z.ZodArray<z.ZodString>>;
@@ -184,11 +186,15 @@ export declare const artifactStudioManifestSchema: z.ZodUnion<readonly [z.ZodObj
             }, z.core.$strict>>;
         }, z.core.$strict>>;
         service_account: z.ZodOptional<z.ZodString>;
-        secrets: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        secrets: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
             name: z.ZodString;
             secret_id: z.ZodUUID;
             version: z.ZodNumber;
-        }, z.core.$strict>>>;
+        }, z.core.$strict>, z.ZodObject<{
+            name: z.ZodString;
+            secret_name: z.ZodString;
+            version: z.ZodNumber;
+        }, z.core.$strict>]>>>;
         egress: z.ZodDefault<z.ZodArray<z.ZodString>>;
         resources: z.ZodPrefault<z.ZodObject<{
             cpu: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<4>, z.ZodLiteral<8>]>>;
@@ -219,6 +225,7 @@ export declare const artifactStudioManifestSchema: z.ZodUnion<readonly [z.ZodObj
                     data: z.ZodPrefault<z.ZodObject<{
                         read: z.ZodDefault<z.ZodArray<z.ZodString>>;
                         write: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                        operations: z.ZodDefault<z.ZodArray<z.ZodString>>;
                     }, z.core.$strict>>;
                     api: z.ZodPrefault<z.ZodObject<{
                         read: z.ZodDefault<z.ZodArray<z.ZodString>>;

package/dist/next-project.d.ts

@@ -17,6 +17,10 @@ export declare function createNextChildEnv({ homeDir, publicEnv, publicOrigin, e
     publicEnv: Record<string, string>;
     publicOrigin: string;
     egressHosts?: readonly string[];
+    /**
+     * The development lease file. Its path in SEQUENCE_ARTIFACT_RUNTIME_FILE is what marks the
+     * runtime as a development lease (`runtimeConfig.development`); a hosted runtime never sets it.
+     */
     runtimeFile?: string;
     source?: NodeJS.ProcessEnv;
 }): NodeJS.ProcessEnv;

package/dist/sdk.d.ts

@@ -13,6 +13,17 @@ export interface SequenceStorageOptions {
     }) => void;
 }
 export interface SequenceStorage {
+    /** Host-owned, caller-authorized PDF/image dialog. Requires a pinned version and declared Storage scope.
+     * Older Atlas builds omit this method; feature-detect before calling. */
+    preview?(input: {
+        workspaceId: string;
+        fileId: string;
+        versionId: string;
+        filename: string;
+        mime: string;
+    }): Promise<{
+        opened: true;
+    }>;
     upload(workspaceId: string, input: StartStorageUpload, file: Blob, options?: SequenceStorageOptions): Promise<StorageUploadSession>;
     resume(workspaceId: string, uploadId: string, file: Blob, options?: SequenceStorageOptions): Promise<StorageUploadSession>;
 }
@@ -400,9 +411,7 @@ export declare function createArtifactStorageClient(sdk?: SequenceArtifactSdk):
             size: number | null;
             contentType: string | null;
         }>;
-        createFolder: (name: string, parentId
-        /** The specific step run (the assignee's task) — the step-scoped id reviewers hold access to. */
-        ? /** The specific step run (the assignee's task) — the step-scoped id reviewers hold access to. */: string | null, { idempotencyKey, }?: {
+        createFolder: (name: string, parentId?: string | null, { idempotencyKey, }?: {
             idempotencyKey?: string;
         }) => Promise<{
             id: string;

package/dist/server/broker-contract.d.ts

@@ -18,6 +18,12 @@ export declare function isArtifactApiPath(path: string): boolean;
 export declare const ARTIFACT_PROCESS_RUN_STATUSES: readonly ["pending", "running", "completed", "failed", "cancelled", "timed_out"];
 /** Lattice lists at most this many runs per call. */
 export declare const ARTIFACT_PROCESS_RUNS_LIMIT = 500;
+/** A run page can filter to at most this many entities of one type. */
+export declare const ARTIFACT_PROCESS_RUN_ENTITIES_LIMIT = 500;
+/** A run share adds collaborators to at most this many explicitly assigned human nodes. */
+export declare const ARTIFACT_PROCESS_SHARE_NODES_LIMIT = 100;
+/** An owner may list at most this many sharing authorities per page. */
+export declare const ARTIFACT_PROCESS_SHARING_AUTHORITIES_LIMIT = 50;
 /** A run-events read returns at most this many events per call, as the run's stream drains them. */
 export declare const ARTIFACT_PROCESS_RUN_EVENTS_LIMIT = 1000;
 /** Which of the user's human steps to list: parked and waiting on them, or already done. */
@@ -31,6 +37,8 @@ export declare const ARTIFACT_PROCESS_PRINCIPAL_SEARCH_LIMIT = 50;
 export declare const ARTIFACT_PROCESS_PRINCIPAL_TYPES: readonly ["user", "group"];
 /** A start seeds assignments for at most this many human nodes. */
 export declare const ARTIFACT_PROCESS_START_ASSIGNMENT_NODES = 64;
+/** The data plane's own idempotency-key rule (`orm-data-plane/src/runtime.ts`), so a key the SDK sends is one it accepts. */
+export declare const artifactOrmIdempotencyKeySchema: z.ZodString;
 export declare const ARTIFACT_FLAGS_PER_REQUEST = 32;
 /** The audit actions an application may record. Sign-in, identity merges and webhooks stay Atlas's. */
 export declare const ARTIFACT_AUDIT_ACTIONS: readonly ["view", "search", "create", "update", "delete", "download", "upload", "export", "import", "share", "submit", "approve", "reject", "execute"];
@@ -64,6 +72,7 @@ export declare const artifactServerRequestSchema: z.ZodDiscriminatedUnion<[z.Zod
     op: z.ZodString;
     variables: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     jsonScalars: z.ZodOptional<z.ZodLiteral<"lossless-v1">>;
+    idempotencyKey: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>, z.ZodObject<{
     operation: z.ZodLiteral<"storage">;
     mode: z.ZodDefault<z.ZodEnum<{
@@ -128,6 +137,29 @@ export declare const artifactServerRequestSchema: z.ZodDiscriminatedUnion<[z.Zod
     }, z.core.$strict>>;
     limit: z.ZodOptional<z.ZodNumber>;
     archived: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>, z.ZodObject<{
+    operation: z.ZodLiteral<"lattice_runs_page">;
+    mode: z.ZodDefault<z.ZodEnum<{
+        service: "service";
+        user: "user";
+    }>>;
+    process: z.ZodString;
+    statuses: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        running: "running";
+        failed: "failed";
+        cancelled: "cancelled";
+        pending: "pending";
+        completed: "completed";
+        timed_out: "timed_out";
+    }>>>;
+    entity: z.ZodOptional<z.ZodObject<{
+        type: z.ZodString;
+        id: z.ZodOptional<z.ZodString>;
+        ids: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    cursor: z.ZodOptional<z.ZodString>;
+    archived: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strict>, z.ZodObject<{
     operation: z.ZodLiteral<"lattice_run">;
     mode: z.ZodDefault<z.ZodEnum<{
@@ -184,6 +216,36 @@ export declare const artifactServerRequestSchema: z.ZodDiscriminatedUnion<[z.Zod
     }>>;
     runId: z.ZodString;
     stepId: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    delegateSharing: z.ZodOptional<z.ZodObject<{
+        audience: z.ZodLiteral<"current_app">;
+    }, z.core.$strict>>;
+    users: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    groups: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    operation: z.ZodLiteral<"lattice_share_run">;
+    mode: z.ZodDefault<z.ZodEnum<{
+        service: "service";
+        user: "user";
+    }>>;
+    runId: z.ZodString;
+    nodeIds: z.ZodArray<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    operation: z.ZodLiteral<"lattice_sharing_authorities">;
+    mode: z.ZodDefault<z.ZodEnum<{
+        service: "service";
+        user: "user";
+    }>>;
+    runId: z.ZodString;
+    limit: z.ZodOptional<z.ZodNumber>;
+    cursor: z.ZodOptional<z.ZodUUID>;
+}, z.core.$strict>, z.ZodObject<{
+    operation: z.ZodLiteral<"lattice_sharing_authority_revoke">;
+    mode: z.ZodDefault<z.ZodEnum<{
+        service: "service";
+        user: "user";
+    }>>;
+    runId: z.ZodString;
+    authorityId: z.ZodUUID;
 }, z.core.$strict>, z.ZodObject<{
     operation: z.ZodLiteral<"lattice_cancel">;
     mode: z.ZodDefault<z.ZodEnum<{

package/dist/server/broker-contract.js

@@ -31,6 +31,12 @@ const latticeVersion = z.string().min(1).max(128).regex(/^[A-Za-z0-9._-]+$/);
 export const ARTIFACT_PROCESS_RUN_STATUSES = ['pending', 'running', 'completed', 'failed', 'cancelled', 'timed_out'];
 /** Lattice lists at most this many runs per call. */
 export const ARTIFACT_PROCESS_RUNS_LIMIT = 500;
+/** A run page can filter to at most this many entities of one type. */
+export const ARTIFACT_PROCESS_RUN_ENTITIES_LIMIT = 500;
+/** A run share adds collaborators to at most this many explicitly assigned human nodes. */
+export const ARTIFACT_PROCESS_SHARE_NODES_LIMIT = 100;
+/** An owner may list at most this many sharing authorities per page. */
+export const ARTIFACT_PROCESS_SHARING_AUTHORITIES_LIMIT = 50;
 /** A run-events read returns at most this many events per call, as the run's stream drains them. */
 export const ARTIFACT_PROCESS_RUN_EVENTS_LIMIT = 1000;
 /** Which of the user's human steps to list: parked and waiting on them, or already done. */
@@ -65,8 +71,14 @@ const assignmentNodeKey = z.string().min(1).max(255).regex(/^[A-Za-z0-9._-]+(?::
 const runAssignments = z.record(assignmentNodeKey, z.object(principalSet).strict().refine(namesPrincipals, PRINCIPAL_SET_MESSAGE))
     .refine((value) => Object.keys(value).length > 0 && Object.keys(value).length <= ARTIFACT_PROCESS_START_ASSIGNMENT_NODES, `Between 1 and ${ARTIFACT_PROCESS_START_ASSIGNMENT_NODES} assigned nodes`);
 const entityRef = z.string().min(1).max(255);
+const runPageEntity = z.object({
+    type: entityRef, id: entityRef.optional(),
+    ids: z.array(entityRef).min(1).max(ARTIFACT_PROCESS_RUN_ENTITIES_LIMIT).optional(),
+}).strict().refine(value => value.id === undefined || value.ids === undefined, 'Name one entity id or a set of ids, not both');
 // Unleash feature names are URL-safe.
 const flagName = z.string().min(1).max(255).regex(/^[A-Za-z0-9._~-]+$/);
+/** The data plane's own idempotency-key rule (`orm-data-plane/src/runtime.ts`), so a key the SDK sends is one it accepts. */
+export const artifactOrmIdempotencyKeySchema = z.string().regex(/^[A-Za-z0-9._:-]{1,128}$/);
 export const ARTIFACT_FLAGS_PER_REQUEST = 32;
 /** The audit actions an application may record. Sign-in, identity merges and webhooks stay Atlas's. */
 export const ARTIFACT_AUDIT_ACTIONS = [
@@ -97,10 +109,13 @@ const auditEvent = {
 export const artifactServerRequestSchema = z.discriminatedUnion('operation', [
     z.object({ operation: z.literal('api'), mode, method, path, body: z.unknown().optional() }).strict(),
     // jsonScalars asks the data plane for exact numeric and bigint strings; Atlas forwards it as
-    // the data plane's own header and passes the acknowledgment back.
+    // the data plane's own header and passes the acknowledgment back. idempotencyKey names one
+    // logical mutation so a retry returns its receipt; Atlas forwards it in the data plane body
+    // (re-scoped per caller for external principals) and the data plane refuses it on a query.
     z.object({
         operation: z.literal('orm'), mode, namespace: id, op: z.string().regex(/^sha256:[a-f0-9]{64}$/),
         variables: z.record(z.string(), z.unknown()).optional(), jsonScalars: z.literal(ORM_LOSSLESS_JSON_SCALARS).optional(),
+        idempotencyKey: artifactOrmIdempotencyKeySchema.optional(),
     }).strict(),
     z.object({ operation: z.literal('storage'), mode, method, path: path.refine(value => {
             const pathname = value.split('?')[0];
@@ -128,6 +143,17 @@ export const artifactServerRequestSchema = z.discriminatedUnion('operation', [
         limit: z.number().int().min(1).max(ARTIFACT_PROCESS_RUNS_LIMIT).optional(),
         archived: z.boolean().optional(),
     }).strict(),
+    // Keyset pagination selects a bounded window from the principal's authorized runs.
+    // Continuation is returned only when another visible run exists; denied rows do not expose a cursor.
+    z.object({
+        operation: z.literal('lattice_runs_page'), mode, process: latticeId,
+        statuses: z.array(z.enum(ARTIFACT_PROCESS_RUN_STATUSES)).min(1).max(ARTIFACT_PROCESS_RUN_STATUSES.length)
+            .refine(value => new Set(value).size === value.length, 'Statuses must be unique').optional(),
+        entity: runPageEntity.optional(),
+        limit: z.number().int().min(1).max(ARTIFACT_PROCESS_RUNS_LIMIT).optional(),
+        cursor: z.string().min(1).max(2048).optional(),
+        archived: z.boolean().optional(),
+    }).strict(),
     // Reads one run the user may view, as `GET /api/lattice/runs/[runId]` does: the run, its steps, the
     // collapsed per-node states and the event cursor to resume its stream from.
     z.object({ operation: z.literal('lattice_run'), mode, runId: latticeId }).strict(),
@@ -162,6 +188,22 @@ export const artifactServerRequestSchema = z.discriminatedUnion('operation', [
     // The user's run `owner` relation decides; the node's assignee allowlist still applies.
     z.object({ operation: z.literal('lattice_assign'), mode, runId: latticeId, stepId: latticeId, ...principalSet }).strict()
         .refine(namesPrincipals, PRINCIPAL_SET_MESSAGE),
+    // Adds collaborators to selected, explicitly assigned human nodes and grants run viewing.
+    // Existing assignees remain. Onward sharing is explicit and scoped to the admitted application.
+    z.object({
+        operation: z.literal('lattice_share_run'), mode, runId: latticeId,
+        nodeIds: z.array(z.string().min(1).max(255).refine(value => !value.includes('::'), 'Node ids cannot contain the reserved :: separator'))
+            .min(1).max(ARTIFACT_PROCESS_SHARE_NODES_LIMIT),
+        ...principalSet,
+        delegateSharing: z.object({ audience: z.literal('current_app') }).strict().optional(),
+    }).strict().refine(namesPrincipals, PRINCIPAL_SET_MESSAGE)
+        .refine(value => !value.delegateSharing || ((value.users?.length ?? 0) > 0 && (value.groups?.length ?? 0) === 0), 'Delegated sharing names individual users only'),
+    z.object({
+        operation: z.literal('lattice_sharing_authorities'), mode, runId: latticeId,
+        limit: z.number().int().min(1).max(ARTIFACT_PROCESS_SHARING_AUTHORITIES_LIMIT).optional(),
+        cursor: z.uuid().optional(),
+    }).strict(),
+    z.object({ operation: z.literal('lattice_sharing_authority_revoke'), mode, runId: latticeId, authorityId: z.uuid() }).strict(),
     // Cancels a run of a process declared under `processes.act`, with its forked lineage, as
     // `POST /api/lattice/runs/[runId]/cancel` does. The user's Invoker relation on the run decides.
     z.object({ operation: z.literal('lattice_cancel'), mode, runId: latticeId }).strict(),

package/dist/server/client.js

@@ -2,7 +2,7 @@ import { randomUUID } from 'node:crypto';
 import { StorageApiError, storageClient, storageErrorSchema } from '@sequenceholdings/storage';
 import { OrmOperationError } from '@sequenceholdings/orm/client';
 import { z } from 'zod';
-import { artifactServerRequestSchema } from './broker-contract.js';
+import { artifactOrmIdempotencyKeySchema, artifactServerRequestSchema } from './broker-contract.js';
 import { createArtifactProcessesClient } from './processes.js';
 import { assertJsonScalarsAcknowledged, ORM_JSON_SCALARS_HEADER } from '../orm-json-scalars.js';
 import { createArtifactLogger } from './logger.js';
@@ -24,6 +24,7 @@ const maxBodyBytes = 1024 * 1024;
 /** A read whose connection failed is sent at most three times, pausing up to 100 ms, then up to 200 ms. */
 const reconnect = { attempts: 3, baseDelayMs: 100 };
 export async function createArtifactServerClient({ headers, runtime, fetch: fetcher = globalThis.fetch, method, path, logSink, accept }) {
+    // An explicit runtime is re-parsed, so it never carries the development-lease marker.
     const config = runtime ? artifactRuntimeConfigSchema.parse(runtime) : await readArtifactRuntimeConfig();
     if (!config)
         throw new ArtifactServerError(401, 'runtime_not_connected', 'Run seq-studio artifact dev to connect platform services, or use a hosted preview.');
@@ -32,7 +33,11 @@ export async function createArtifactServerClient({ headers, runtime, fetch: fetc
     if (accept && isExternalContextToken(token)) {
         if (!method || !path)
             throw new ArtifactServerError(401, 'invalid_request_context', 'An external request context is verified only against the route method and path');
-        context = verifyArtifactExternalContext({ token, publicKeys: config.publicKeys, projectId: config.projectId, environment: config.environment, method, path, accept });
+        context = verifyArtifactExternalContext({
+            token, publicKeys: config.publicKeys, projectId: config.projectId, environment: config.environment, method, path, accept,
+            // A development context only under a development lease (never a hosted or explicit runtime).
+            developmentSessionId: config.development === true ? config.devSessionId : undefined,
+        });
     }
     else {
         context = verifyArtifactRequestContext({ token, publicKeys: config.publicKeys, projectId: config.projectId, environment: config.environment, method, path });
@@ -42,7 +47,7 @@ export async function createArtifactServerClient({ headers, runtime, fetch: fetc
         throw new ArtifactServerError(401, 'invalid_runtime_session', 'Artifact request does not belong to this runtime');
     const getRuntime = async () => {
         const current = runtime ? config : await readArtifactRuntimeConfig();
-        if (!current || current.projectId !== config.projectId || current.environment !== config.environment || current.atlasUrl !== config.atlasUrl || current.devSessionId !== config.devSessionId || current.deploymentId !== config.deploymentId)
+        if (!current || current.projectId !== config.projectId || current.environment !== config.environment || current.atlasUrl !== config.atlasUrl || current.devSessionId !== config.devSessionId || current.deploymentId !== config.deploymentId || current.development !== config.development)
             throw new ArtifactServerError(401, 'runtime_changed', 'Artifact runtime disconnected or changed; reload the preview');
         return current;
     };
@@ -97,14 +102,9 @@ function buildClient(args) {
         },
         audit: { record: (event) => recordAuditEvent({ request, mode, event }) },
         orm: ({ namespace, manifest, jsonScalars }) => ({
-            async execute(op, variables = {}) {
-                const listed = op.startsWith('sha256:') ? Object.values(manifest.operations).find(entry => entry.hash === op) : manifest.operations[op];
-                const hash = op.startsWith('sha256:') ? op : listed?.hash;
-                if (!hash)
-                    throw new ArtifactServerError(400, 'unknown_orm_operation', 'ORM operation is not in the generated manifest; run seq-studio orm generate');
-                const response = await request(artifactServerRequestSchema.parse({ operation: 'orm', mode, namespace, op: hash, variables, ...(jsonScalars ? { jsonScalars } : {}) }), 
-                // Only an operation the manifest lists as a query is known to change nothing.
-                { replaySafe: listed?.kind === 'query' });
+            async execute(op, variables = {}, options = {}) {
+                const { operation, replaySafe } = ormOperationRequest({ mode, namespace, manifest, op, variables, jsonScalars, idempotencyKey: options.idempotencyKey });
+                const response = await request(operation, { replaySafe });
                 const body = await response.json().catch(() => null);
                 const stepUp = stepUpError(response.status, body);
                 if (stepUp)
@@ -130,6 +130,30 @@ function buildClient(args) {
         },
     };
 }
+/**
+ * The broker `orm` request for one persisted operation, and whether a lost connection may resend
+ * it: an operation the manifest lists as a query changes nothing, and a mutation sent with an
+ * idempotency key is answered from its stored receipt when it arrives twice (the same body carries
+ * the same key and fingerprint).
+ */
+function ormOperationRequest({ mode, namespace, manifest, op, variables, jsonScalars, idempotencyKey }) {
+    const listed = op.startsWith('sha256:') ? Object.values(manifest.operations).find(entry => entry.hash === op) : manifest.operations[op];
+    const hash = op.startsWith('sha256:') ? op : listed?.hash;
+    if (!hash)
+        throw new ArtifactServerError(400, 'unknown_orm_operation', 'ORM operation is not in the generated manifest; run seq-studio orm generate');
+    const query = listed?.kind === 'query';
+    // A key names one mutation's receipt; the data plane refuses one on a query, so refuse it before the call.
+    if (idempotencyKey !== undefined && query)
+        throw new ArtifactServerError(400, 'idempotency_key_on_query', 'An idempotency key applies only to a mutation');
+    if (idempotencyKey !== undefined && !artifactOrmIdempotencyKeySchema.safeParse(idempotencyKey).success) {
+        throw new ArtifactServerError(400, 'invalid_idempotency_key', 'Idempotency keys are 1-128 letters, digits, dots, underscores, colons or hyphens');
+    }
+    const operation = artifactServerRequestSchema.parse({
+        operation: 'orm', mode, namespace, op: hash, variables,
+        ...(jsonScalars ? { jsonScalars } : {}), ...(idempotencyKey === undefined ? {} : { idempotencyKey }),
+    });
+    return { operation, replaySafe: query || idempotencyKey !== undefined };
+}
 /**
  * Sends one audit event, and once more with the same event id when Atlas couldn't confirm delivery
  * (503, or no answer): Atlas derives the stored event id from it and the request, so the audit sink
@@ -231,8 +255,9 @@ function createBrokerTransport({ context, principal, token, getRuntime, fetcher,
     /**
      * Sends a read again when its connection to Atlas failed before Atlas answered: such failures
      * clear within moments, and a read changes nothing by arriving twice. A write is never sent
-     * again, because a reset can come after Atlas acted on it. A response, whatever its status, is
-     * Atlas's answer and is returned as is.
+     * again, because a reset can come after Atlas acted on it, unless its caller marks it replay-safe
+     * (an ORM mutation carrying an idempotency key). A response, whatever its status, is Atlas's
+     * answer and is returned as is.
      */
     return async (input, { signal, replaySafe = isReadOperation(input), stream = false } = {}) => {
         for (let attempt = 1;; attempt++) {

package/dist/server/external-context.d.ts

@@ -9,7 +9,7 @@ export interface ArtifactExternalAccept {
  * bound to the one route it was signed for. Refuses a v1 context (`external_context_required`)
  * and a context from an ingress the handler did not name (`external_ingress_not_accepted`).
  */
-export declare function verifyArtifactExternalContext({ token, publicKeys, projectId, environment, method, path, accept, now }: {
+export declare function verifyArtifactExternalContext({ token, publicKeys, projectId, environment, method, path, accept, developmentSessionId, now }: {
     token: string | null;
     publicKeys: ArtifactGatewayPublicKeys;
     projectId: string;
@@ -17,5 +17,12 @@ export declare function verifyArtifactExternalContext({ token, publicKeys, proje
     method: string;
     path: string;
     accept: ArtifactExternalAccept;
+    /**
+     * Set only when this runtime runs under a development lease (`runtimeConfig.development`): its
+     * session id. A `development`-mode context is accepted only then, and only for that session; a
+     * hosted runtime leaves it unset and refuses every development context
+     * (`external_mode_not_accepted`).
+     */
+    developmentSessionId?: string;
     now?: number;
 }): RequestContextV2External;