@sequenceholdings/artifact-studio 0.4.0 → 0.6.1

package/dist/runtime-contracts.d.ts

@@ -72,9 +72,9 @@ export declare const artifactOperationSchema: z.ZodDiscriminatedUnion<[z.ZodObje
     projectId: z.ZodString;
     environment: z.ZodString;
     kind: z.ZodEnum<{
-        preview: "preview";
         build: "build";
         deploy: "deploy";
+        preview: "preview";
         rollback: "rollback";
         suspend: "suspend";
         delete: "delete";
@@ -92,9 +92,9 @@ export declare const artifactOperationSchema: z.ZodDiscriminatedUnion<[z.ZodObje
     projectId: z.ZodString;
     environment: z.ZodString;
     kind: z.ZodEnum<{
-        preview: "preview";
         build: "build";
         deploy: "deploy";
+        preview: "preview";
         rollback: "rollback";
         suspend: "suspend";
         delete: "delete";
@@ -109,9 +109,9 @@ export declare const artifactOperationSchema: z.ZodDiscriminatedUnion<[z.ZodObje
     projectId: z.ZodString;
     environment: z.ZodString;
     kind: z.ZodEnum<{
-        preview: "preview";
         build: "build";
         deploy: "deploy";
+        preview: "preview";
         rollback: "rollback";
         suspend: "suspend";
         delete: "delete";
@@ -130,9 +130,9 @@ export declare const artifactOperationSchema: z.ZodDiscriminatedUnion<[z.ZodObje
     projectId: z.ZodString;
     environment: z.ZodString;
     kind: z.ZodEnum<{
-        preview: "preview";
         build: "build";
         deploy: "deploy";
+        preview: "preview";
         rollback: "rollback";
         suspend: "suspend";
         delete: "delete";
@@ -147,9 +147,9 @@ export declare const artifactOperationSchema: z.ZodDiscriminatedUnion<[z.ZodObje
     projectId: z.ZodString;
     environment: z.ZodString;
     kind: z.ZodEnum<{
-        preview: "preview";
         build: "build";
         deploy: "deploy";
+        preview: "preview";
         rollback: "rollback";
         suspend: "suspend";
         delete: "delete";
@@ -164,9 +164,9 @@ export declare const artifactRuntimeSessionSchema: z.ZodObject<{
     projectId: z.ZodString;
     environment: z.ZodString;
     mode: z.ZodEnum<{
+        local: "local";
         preview: "preview";
         published: "published";
-        local: "local";
     }>;
     origin: z.ZodString;
     parentOrigin: z.ZodString;
@@ -187,12 +187,12 @@ export declare const artifactLocalDevSessionSchema: z.ZodObject<{
     sourceRevision: z.ZodOptional<z.ZodString>;
     revision: z.ZodNumber;
     state: z.ZodEnum<{
+        offline: "offline";
         failed: "failed";
         starting: "starting";
         compiling: "compiling";
         ready: "ready";
         reconnecting: "reconnecting";
-        offline: "offline";
         revoked: "revoked";
         expired: "expired";
     }>;

package/dist/runtime-contracts.js

@@ -20,7 +20,7 @@ const imageReferenceSchema = z.string().max(1024).regex(/^[a-z0-9]+(?:[.-][a-z0-
 const excludedSourceSegments = new Set([
     '.git', 'node_modules', '.next', '.npmrc', '.netrc', '.aws', '.ssh', '.config',
     'dist', '.artifact-studio', '.git-credentials', '.pypirc', '.azure', '.gcloud', '.doppler',
-    '.turbo', 'coverage', '.docker',
+    '.turbo', 'coverage', '.docker', '.seq-next-output.json',
 ]);
 /** Shared upload exclusion policy. Content scanning and filesystem containment remain separate checks. */
 export function isExcludedArtifactSourcePath({ path }) {

package/dist/sdk-orm.d.ts

@@ -1,4 +1,5 @@
 import { type OperationExecutor } from '@sequenceholdings/orm/client';
+import { type ArtifactOrmJsonScalars } from './orm-json-scalars.js';
 import { type SequenceApi } from './sdk.js';
 export interface ArtifactOrmExecutorConfig {
     namespace: string;
@@ -8,6 +9,11 @@ export interface ArtifactOrmExecutorConfig {
     sdk?: {
         api: Pick<SequenceApi, 'fetch'>;
     };
+    /**
+     * `lossless-v1` returns numeric and bigint values as strings instead of JSON numbers.
+     * The executor refuses any successful result the host does not acknowledge in that form.
+     */
+    jsonScalars?: ArtifactOrmJsonScalars;
 }
 /**
  * Execute persisted operations as the signed-in Artifact user. The host owns
@@ -15,4 +21,4 @@ export interface ArtifactOrmExecutorConfig {
  * Declare the namespace path in capabilities.api.write (queries also use POST).
  * Namespace grants, capabilities, row policies, and write checks still apply.
  */
-export declare function createArtifactOrmExecutor({ namespace, manifest, sdk }: ArtifactOrmExecutorConfig): OperationExecutor;
+export declare function createArtifactOrmExecutor({ namespace, manifest, sdk, jsonScalars }: ArtifactOrmExecutorConfig): OperationExecutor;

package/dist/sdk-orm.js

@@ -1,4 +1,5 @@
 import { createOperationExecutorWithTransport, OrmClientError } from '@sequenceholdings/orm/client';
+import { assertJsonScalarsAcknowledged, ORM_JSON_SCALARS_HEADER } from './orm-json-scalars.js';
 import { seq } from './sdk.js';
 /**
  * Execute persisted operations as the signed-in Artifact user. The host owns
@@ -6,16 +7,22 @@ import { seq } from './sdk.js';
  * Declare the namespace path in capabilities.api.write (queries also use POST).
  * Namespace grants, capabilities, row policies, and write checks still apply.
  */
-export function createArtifactOrmExecutor({ namespace, manifest, sdk = seq }) {
+export function createArtifactOrmExecutor({ namespace, manifest, sdk = seq, jsonScalars }) {
     if (!sdk || typeof sdk.api?.fetch !== 'function') {
         throw new OrmClientError('Artifact ORM requires the authenticated Artifact Studio host; open the deployed artifact or its Preview');
     }
     return createOperationExecutorWithTransport({
         namespace,
         manifest,
-        transport: ({ namespace: target, op, variables }) => sdk.api.fetch(`/api/data/v2/${target}`, {
-            method: 'POST',
-            body: { op, variables },
-        }),
+        transport: async ({ namespace: target, op, variables, idempotencyKey }) => {
+            const response = await sdk.api.fetch(`/api/data/v2/${target}`, {
+                method: 'POST',
+                body: { op, variables, ...(idempotencyKey === undefined ? {} : { idempotencyKey }) },
+                ...(jsonScalars ? { headers: { [ORM_JSON_SCALARS_HEADER]: jsonScalars } } : {}),
+            });
+            if (response.ok)
+                assertJsonScalarsAcknowledged({ requested: jsonScalars, acknowledged: response.headers?.[ORM_JSON_SCALARS_HEADER], status: response.status });
+            return response;
+        },
     });
 }

package/dist/sdk.d.ts

@@ -1,5 +1,8 @@
+import type { SequenceOfflineManagement } from './offline/management-types.js';
+export type { SequenceOfflineManagement, SequenceOfflineManagementStatus, SequenceOfflineManagementIssue } from './offline/management-types.js';
 import { type StartStorageUpload, type StorageUploadSession } from '@sequenceholdings/storage';
 export { createArtifactOrmExecutor, type ArtifactOrmExecutorConfig } from './sdk-orm.js';
+export type { ArtifactOrmJsonScalars } from './orm-json-scalars.js';
 export interface SequenceStorageOptions {
     signal?: AbortSignal;
     timeoutMs?: number;
@@ -48,6 +51,57 @@ export interface SequenceApi {
     patch<TBody = unknown>(path: string, body?: unknown): Promise<TBody>;
     delete<TBody = unknown>(path: string, body?: unknown): Promise<TBody>;
 }
+export type SequenceOfflineRequestMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+export interface SequenceOfflineRequest {
+    method: SequenceOfflineRequestMethod;
+    path: string;
+    body?: unknown;
+    headers?: Record<string, string>;
+}
+export interface SequenceOfflineConnectorExecution<TBody = unknown> {
+    request: SequenceOfflineRequest;
+    /**
+     * Invoke the authenticated Artifact Studio bridge. Authentication remains
+     * host-owned and is never exposed to the connector or durable storage.
+     */
+    network: (request: SequenceOfflineRequest) => Promise<SequenceApiFetchResponse<TBody>>;
+}
+export interface SequenceOfflineNetwork {
+    execute<TBody = unknown>(request: SequenceOfflineRequest): Promise<SequenceApiFetchResponse<TBody>>;
+}
+export interface SequenceOfflineRequestConnector {
+    execute<TBody = unknown>(execution: SequenceOfflineConnectorExecution<TBody>): Promise<SequenceApiFetchResponse<TBody>>;
+    /**
+     * Receives a capability-gated bridge executor for durable outbox replay.
+     * It carries no bearer token and remains subject to the active manifest.
+     */
+    attach?(context: {
+        network: SequenceOfflineNetwork;
+    }): void | (() => void);
+}
+export interface SequenceOffline {
+    registerManagement(adapter: SequenceOfflineManagement): () => void;
+    openSettings(): Promise<void>;
+    isManagementSession(): boolean;
+    /**
+     * Install the artifact's request policy beneath seq.api. Returns a disposer
+     * that restores the network-only default when it still owns registration.
+     */
+    registerConnector(registration: {
+        connector: SequenceOfflineRequestConnector;
+    }): () => void;
+    /** Cache the current artifact shell on this device after the user's opt-in. */
+    enroll(options?: {
+        maxAgeHours?: number;
+    }): Promise<void>;
+    /** Remove this artifact's cached shell. App-owned data should be wiped too. */
+    remove(): Promise<void>;
+    status(): Promise<{
+        enabled: boolean;
+        enrolled: boolean;
+        expiresAt?: number;
+    }>;
+}
 export interface SequenceFunctions {
     invoke<TOutput = unknown>(id: string, params?: Record<string, unknown>, traceAction?: {
         id: string;
@@ -135,6 +189,7 @@ export interface SequenceHost {
 export interface SequenceArtifactSdk {
     storage: SequenceStorage;
     api: SequenceApi;
+    offline: SequenceOffline;
     ai: {
         fetch(path: string, options?: SequenceApiFetchOptions): Promise<Response>;
     };
@@ -211,6 +266,73 @@ export declare function createArtifactStorageClient(sdk?: SequenceArtifactSdk):
                 versionId: string | null;
                 maxBytes: number;
             }>;
+            startBatch: (items: StartStorageUpload[]) => Promise<{
+                items: {
+                    id: string;
+                    fileId: string;
+                    uploadUrl: string | null;
+                    expiresAt: string;
+                    state: "pending" | "complete" | "aborted";
+                    versionId: string | null;
+                    maxBytes: number;
+                }[];
+            }>;
+            list: () => Promise<{
+                items: {
+                    id: string;
+                    fileId: string;
+                    name: string;
+                    state: "pending" | "complete" | "aborted";
+                    expiresAt: string;
+                    maxBytes: number;
+                    expectedSize: number | null;
+                    versionId: string | null;
+                }[];
+                limits: {
+                    perPrincipal: number;
+                    perWorkspace: number;
+                };
+            }>;
+            reconcile: (input?: {
+                abortIncomplete?: boolean;
+            }) => Promise<{
+                completed: {
+                    id: string;
+                    fileId: string;
+                    name: string;
+                    state: "pending" | "complete" | "aborted";
+                    expiresAt: string;
+                    maxBytes: number;
+                    expectedSize: number | null;
+                    versionId: string | null;
+                    code: string;
+                    message: string;
+                }[];
+                aborted: {
+                    id: string;
+                    fileId: string;
+                    name: string;
+                    state: "pending" | "complete" | "aborted";
+                    expiresAt: string;
+                    maxBytes: number;
+                    expectedSize: number | null;
+                    versionId: string | null;
+                    code: string;
+                    message: string;
+                }[];
+                pending: {
+                    id: string;
+                    fileId: string;
+                    name: string;
+                    state: "pending" | "complete" | "aborted";
+                    expiresAt: string;
+                    maxBytes: number;
+                    expectedSize: number | null;
+                    versionId: string | null;
+                    code: string;
+                    message: string;
+                }[];
+            }>;
         };
         get: () => Promise<{
             id: string;
@@ -278,7 +400,9 @@ export declare function createArtifactStorageClient(sdk?: SequenceArtifactSdk):
             size: number | null;
             contentType: string | null;
         }>;
-        createFolder: (name: string, parentId?: string | null, { idempotencyKey, }?: {
+        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, }?: {
             idempotencyKey?: string;
         }) => Promise<{
             id: string;
@@ -489,6 +613,15 @@ export declare function createArtifactStorageClient(sdk?: SequenceArtifactSdk):
     capabilities: () => Promise<{
         canProvision: boolean;
         uploadMethods: string[];
+        pendingUploads: {
+            perPrincipal: number;
+            perWorkspace: number;
+        };
+        uploadBatchLimit: number;
+        importConcurrency: {
+            default: number;
+            max: number;
+        };
     }>;
     list: (options?: import("@sequenceholdings/storage").StorageListOptions) => Promise<{
         items: {

package/dist/server/api-client.d.ts

@@ -0,0 +1,26 @@
+import type { SequenceApiFetchResponse } from '../sdk.js';
+import { type ArtifactServerMode, type ArtifactServerRequest } from './broker-contract.js';
+export interface ArtifactServerFetchOptions {
+    method?: 'GET' | 'HEAD' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+    body?: unknown;
+    signal?: AbortSignal;
+}
+/** Sends one broker operation; the client's transport (retries, the external-principal gate). */
+export type ArtifactBrokerRequest = (operation: ArtifactServerRequest, options?: {
+    signal?: AbortSignal;
+}) => Promise<Response>;
+/** `client.api`: Atlas routes reached through the broker as `api` operations. */
+export declare function createApiClient({ mode, request, json }: {
+    mode: ArtifactServerMode;
+    request: ArtifactBrokerRequest;
+    json: (operation: ArtifactServerRequest, signal?: AbortSignal) => Promise<unknown>;
+}): {
+    request: (path: string, options?: ArtifactServerFetchOptions) => Promise<Response>;
+    fetch<TBody = unknown>(path: string, options?: ArtifactServerFetchOptions): Promise<SequenceApiFetchResponse<TBody>>;
+    stream(path: string, options?: ArtifactServerFetchOptions): Promise<ReadableStream<Uint8Array<ArrayBuffer>>>;
+    get: <T = unknown>(path: string) => Promise<T>;
+    post: <T = unknown>(path: string, body?: unknown) => Promise<T>;
+    put: <T = unknown>(path: string, body?: unknown) => Promise<T>;
+    patch: <T = unknown>(path: string, body?: unknown) => Promise<T>;
+    delete: <T = unknown>(path: string, body?: unknown) => Promise<T>;
+};

package/dist/server/api-client.js

@@ -0,0 +1,38 @@
+import { artifactServerRequestSchema } from './broker-contract.js';
+import { ArtifactServerError, stepUpErrorFromResponse } from './errors.js';
+const responseHeaders = ['content-type', 'content-disposition', 'content-length', 'retry-after'];
+/** `client.api`: Atlas routes reached through the broker as `api` operations. */
+export function createApiClient({ mode, request, json }) {
+    const operation = (path, options = {}) => artifactServerRequestSchema.parse({ operation: 'api', mode, method: options.method ?? 'GET', path, body: options.body });
+    const fetchResponse = (path, options = {}) => request(operation(path, options), { signal: options.signal });
+    const typedJson = async (path, options = {}) => {
+        // Explicit caller result types match the existing browser SDK; the server validates endpoint schemas.
+        return await json(operation(path, options), options.signal);
+    };
+    return {
+        request: fetchResponse,
+        async fetch(path, options = {}) {
+            const response = await fetchResponse(path, options);
+            const contentType = response.headers.get('content-type') ?? '';
+            const body = response.status === 204 ? undefined : contentType.includes('json') ? await response.json() : await response.arrayBuffer();
+            // The caller declares the endpoint's response type, consistent with SequenceApiFetchResponse.
+            return { ok: response.ok, status: response.status, body: body, headers: Object.fromEntries(responseHeaders.flatMap(key => {
+                    const value = response.headers.get(key);
+                    return value === null ? [] : [[key, value]];
+                })) };
+        },
+        async stream(path, options = {}) {
+            const response = await fetchResponse(path, options);
+            if (!response.ok || !response.body) {
+                throw await stepUpErrorFromResponse(response) ??
+                    new ArtifactServerError(response.status, 'stream_unavailable', 'Atlas did not return a readable response');
+            }
+            return response.body;
+        },
+        get: (path) => typedJson(path),
+        post: (path, body) => typedJson(path, { method: 'POST', body }),
+        put: (path, body) => typedJson(path, { method: 'PUT', body }),
+        patch: (path, body) => typedJson(path, { method: 'PATCH', body }),
+        delete: (path, body) => typedJson(path, { method: 'DELETE', body }),
+    };
+}

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

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+export { ORM_JSON_SCALARS_HEADER, ORM_LOSSLESS_JSON_SCALARS, type ArtifactOrmJsonScalars } from '../orm-json-scalars.js';
 export declare const artifactServerMethodSchema: z.ZodEnum<{
     GET: "GET";
     POST: "POST";
@@ -8,17 +9,38 @@ export declare const artifactServerMethodSchema: z.ZodEnum<{
     PATCH: "PATCH";
 }>;
 export declare const artifactServerModeSchema: z.ZodDefault<z.ZodEnum<{
-    user: "user";
     service: "service";
+    user: "user";
 }>>;
 /** Reject paths that intermediaries can normalize into a different authorization target. */
 export declare function isArtifactApiPath(path: string): boolean;
+/** A Lattice run's lifecycle status, as `GET /api/lattice/runs` filters it. */
+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;
+/** Which of the user's human steps to list: parked and waiting on them, or already done. */
+export declare const ARTIFACT_PROCESS_TASK_VIEWS: readonly ["active", "completed"];
+/** Lattice lists at most this many human steps per call, as its own inbox does. */
+export declare const ARTIFACT_PROCESS_TASKS_LIMIT = 500;
+/** A grant or revocation names at most this many users and groups together. */
+export declare const ARTIFACT_PROCESS_PRINCIPALS_PER_CALL = 100;
+/** A principal search returns at most this many users and groups together, as Lattice's own picker. */
+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;
+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"];
+/** One bulk action (archive the 100 selected applications) is one event naming each of them. */
+export declare const ARTIFACT_AUDIT_RESOURCES_PER_EVENT = 100;
+export declare const ARTIFACT_AUDIT_METADATA_KEYS = 32;
 /** Atlas validates these operations against current manifest, bindings and principal grants. */
 export declare const artifactServerRequestSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     operation: z.ZodLiteral<"api">;
     mode: z.ZodDefault<z.ZodEnum<{
-        user: "user";
         service: "service";
+        user: "user";
     }>>;
     method: z.ZodEnum<{
         GET: "GET";
@@ -33,17 +55,18 @@ export declare const artifactServerRequestSchema: z.ZodDiscriminatedUnion<[z.Zod
 }, z.core.$strict>, z.ZodObject<{
     operation: z.ZodLiteral<"orm">;
     mode: z.ZodDefault<z.ZodEnum<{
-        user: "user";
         service: "service";
+        user: "user";
     }>>;
     namespace: z.ZodString;
     op: z.ZodString;
     variables: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    jsonScalars: z.ZodOptional<z.ZodLiteral<"lossless-v1">>;
 }, z.core.$strict>, z.ZodObject<{
     operation: z.ZodLiteral<"storage">;
     mode: z.ZodDefault<z.ZodEnum<{
-        user: "user";
         service: "service";
+        user: "user";
     }>>;
     method: z.ZodEnum<{
         GET: "GET";
@@ -58,11 +81,174 @@ export declare const artifactServerRequestSchema: z.ZodDiscriminatedUnion<[z.Zod
 }, z.core.$strict>, z.ZodObject<{
     operation: z.ZodLiteral<"function">;
     mode: z.ZodDefault<z.ZodEnum<{
-        user: "user";
         service: "service";
+        user: "user";
     }>>;
     id: z.ZodString;
     params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strict>, z.ZodObject<{
+    operation: z.ZodLiteral<"lattice">;
+    mode: z.ZodDefault<z.ZodEnum<{
+        service: "service";
+        user: "user";
+    }>>;
+    process: z.ZodString;
+    runId: z.ZodOptional<z.ZodString>;
+    title: z.ZodOptional<z.ZodString>;
+    entity: z.ZodOptional<z.ZodObject<{
+        type: z.ZodString;
+        id: z.ZodString;
+    }, z.core.$strict>>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    assignments: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        users: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        groups: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>, z.ZodObject<{
+    operation: z.ZodLiteral<"lattice_runs">;
+    mode: z.ZodDefault<z.ZodEnum<{
+        service: "service";
+        user: "user";
+    }>>;
+    process: z.ZodString;
+    status: z.ZodOptional<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>;
+    }, z.core.$strict>>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    archived: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>, z.ZodObject<{
+    operation: z.ZodLiteral<"lattice_run">;
+    mode: z.ZodDefault<z.ZodEnum<{
+        service: "service";
+        user: "user";
+    }>>;
+    runId: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    operation: z.ZodLiteral<"lattice_process">;
+    mode: z.ZodDefault<z.ZodEnum<{
+        service: "service";
+        user: "user";
+    }>>;
+    process: z.ZodString;
+    version: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    operation: z.ZodLiteral<"lattice_tasks">;
+    mode: z.ZodDefault<z.ZodEnum<{
+        service: "service";
+        user: "user";
+    }>>;
+    processes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    view: z.ZodOptional<z.ZodEnum<{
+        active: "active";
+        completed: "completed";
+    }>>;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>, z.ZodObject<{
+    operation: z.ZodLiteral<"lattice_advance">;
+    mode: z.ZodDefault<z.ZodEnum<{
+        service: "service";
+        user: "user";
+    }>>;
+    runId: z.ZodString;
+    stepId: z.ZodOptional<z.ZodString>;
+    edgeId: z.ZodOptional<z.ZodString>;
+    payload: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strict>, z.ZodObject<{
+    users: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    groups: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    operation: z.ZodLiteral<"lattice_assign">;
+    mode: z.ZodDefault<z.ZodEnum<{
+        service: "service";
+        user: "user";
+    }>>;
+    runId: z.ZodString;
+    stepId: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    operation: z.ZodLiteral<"lattice_viewers">;
+    mode: z.ZodDefault<z.ZodEnum<{
+        service: "service";
+        user: "user";
+    }>>;
+    runId: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    users: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    groups: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    operation: z.ZodLiteral<"lattice_viewer_grant">;
+    mode: z.ZodDefault<z.ZodEnum<{
+        service: "service";
+        user: "user";
+    }>>;
+    runId: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    users: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    groups: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    operation: z.ZodLiteral<"lattice_viewer_revoke">;
+    mode: z.ZodDefault<z.ZodEnum<{
+        service: "service";
+        user: "user";
+    }>>;
+    runId: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    operation: z.ZodLiteral<"lattice_principals">;
+    mode: z.ZodDefault<z.ZodEnum<{
+        service: "service";
+        user: "user";
+    }>>;
+    q: z.ZodString;
+    types: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        user: "user";
+        group: "group";
+    }>>>;
+    limit: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>, z.ZodObject<{
+    operation: z.ZodLiteral<"flags">;
+    mode: z.ZodDefault<z.ZodEnum<{
+        service: "service";
+        user: "user";
+    }>>;
+    names: z.ZodArray<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    eventId: z.ZodUUID;
+    action: z.ZodEnum<{
+        search: "search";
+        delete: "delete";
+        import: "import";
+        share: "share";
+        upload: "upload";
+        submit: "submit";
+        view: "view";
+        create: "create";
+        update: "update";
+        download: "download";
+        export: "export";
+        approve: "approve";
+        reject: "reject";
+        execute: "execute";
+    }>;
+    detail: z.ZodString;
+    resources: z.ZodArray<z.ZodObject<{
+        type: z.ZodString;
+        id: z.ZodString;
+    }, z.core.$strict>>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>>>;
+    operation: z.ZodLiteral<"audit">;
+    mode: z.ZodDefault<z.ZodEnum<{
+        service: "service";
+        user: "user";
+    }>>;
 }, z.core.$strict>], "operation">;
 export type ArtifactServerRequest = z.infer<typeof artifactServerRequestSchema>;
 export type ArtifactServerMode = z.infer<typeof artifactServerModeSchema>;
+export type ArtifactAuditAction = (typeof ARTIFACT_AUDIT_ACTIONS)[number];
+export type ArtifactProcessRunStatus = (typeof ARTIFACT_PROCESS_RUN_STATUSES)[number];
+export type ArtifactProcessTaskView = (typeof ARTIFACT_PROCESS_TASK_VIEWS)[number];
+export type ArtifactProcessPrincipalType = (typeof ARTIFACT_PROCESS_PRINCIPAL_TYPES)[number];