@sequenceholdings/artifact-studio 0.6.4 → 0.6.6

package/dist/gateway/server.js

@@ -13,6 +13,9 @@ import { gatewayClientAddress } from './control-admission.js';
 import { gatewayAuthorizationKey, PositiveDecisionCache, tunnelAuthorizationKey } from './authorization-cache.js';
 import { GatewayUsageReporter } from './usage.js';
 import { artifactNextFrameworkBuildIdSchema } from '../runtime-contracts.js';
+import { createDevelopmentIngressProxy } from './ingress-development.js';
+import { createIngressHandler, handleClientErrors } from './ingress-handler.js';
+import { resemblesIngressHost } from './ingress.js';
 function json(response, status, error) {
     if (response.headersSent) {
         response.destroy();
@@ -115,6 +118,7 @@ export function createArtifactGateway(options) {
     const tunnelAuthorizations = new PositiveDecisionCache({ ttlMs: options.authorizationCacheTtlMs });
     const usage = new GatewayUsageReporter({ send: events => options.control.usage(events), onFailure: failure => options.onError?.(failure) });
     let draining = false;
+    const isIngressRequest = (request) => resemblesIngressHost({ rawHost: header(request, 'host'), runtimeDomain: options.runtimeDomain });
     /** Admission for the unauthenticated endpoints; the release frees the in-flight permit. */
     async function admitControlCall(endpoint, request) {
         if (!options.controlAdmission)
@@ -254,7 +258,16 @@ export function createArtifactGateway(options) {
         onTunnelClosed: lease => { if (leases.get(lease.sessionId)?.lease.epoch === lease.epoch)
             leases.delete(lease.sessionId); },
     });
+    // A development target is proxied over its session tunnel only by a development gateway (design §(j.3) step 3).
+    const proxyDevelopment = options.ingress?.appEnv === 'development' ? createDevelopmentIngressProxy({ broker }) : undefined;
+    const ingress = createIngressHandler({ options: options.ingress, runtimeDomain: options.runtimeDomain, protocol: new URL(gatewayOrigin).protocol, isDraining: () => draining, onError: options.onError, usage, proxyDevelopment });
     const server = createServer({ maxHeaderSize: 32 * 1024, requestTimeout: 60_000, headersTimeout: 15_000 }, (request, response) => {
+        // Before readiness, bootstrap and requestOrigin(): an ingress host, canonical or not, never
+        // reaches a session-path handler or the 401/404→403 remap below (design §(e) "Branch placement").
+        if (isIngressRequest(request)) {
+            void ingress.handle(request, response);
+            return;
+        }
         const startedAt = new Date().toISOString(), started = performance.now();
         void (async () => {
             if (isReadinessRequest({ request, gatewayOrigin, runtimeDomain: options.runtimeDomain })) {
@@ -350,6 +363,11 @@ export function createArtifactGateway(options) {
                 rejectUpgrade(socket, 503);
                 return;
             }
+            // An ingress answers data requests only: no WebSocket, no tunnel.
+            if (isIngressRequest(request)) {
+                rejectUpgrade(socket, 404);
+                return;
+            }
             if (request.url === '/_sequence/tunnel') {
                 await broker.handleTunnelUpgrade(request, socket, head);
                 return;
@@ -362,6 +380,9 @@ export function createArtifactGateway(options) {
             await broker.handleWebSocketUpgrade(request, socket, head, authorized.target.sessionId);
         })().catch(() => rejectUpgrade(socket));
     });
+    // Only with the ingress branch configured: without it, Node's own clientError replies stay untouched.
+    if (options.ingress)
+        handleClientErrors({ server, ingress });
     return {
         server,
         /** Observations recorded but not yet confirmed by Atlas: what a forced exit would lose. */

package/dist/gateway/session-response.d.ts

@@ -0,0 +1,15 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+/** Response-header rules for the iframe session path of the hosted proxy (an ingress uses `ingress-response.ts`). */
+export declare function rewriteLocation({ location, upstream, publicOrigin }: {
+    location: string;
+    upstream: URL;
+    publicOrigin: string;
+}): string;
+export declare function mergeFramePolicy({ application, trusted }: {
+    application: string | string[];
+    trusted: string | string[];
+}): string[];
+export declare function enforceBrowserCachePolicy({ request, response }: {
+    request: IncomingMessage;
+    response: ServerResponse;
+}): void;

package/dist/gateway/session-response.js

@@ -0,0 +1,40 @@
+import { isSharedCacheDirective, SHARED_CACHE_REFUSAL } from '../tunnel/protocol.js';
+/** Response-header rules for the iframe session path of the hosted proxy (an ingress uses `ingress-response.ts`). */
+export function rewriteLocation({ location, upstream, publicOrigin }) {
+    if (!/^(?:https?:)?\/\//i.test(location))
+        return location;
+    const url = new URL(location, upstream);
+    return url.origin === upstream.origin ? `${publicOrigin}${url.pathname}${url.search}${url.hash}` : location;
+}
+export function mergeFramePolicy({ application, trusted }) {
+    const policies = Array.isArray(application) ? application : [application];
+    const frames = Array.isArray(trusted) ? trusted : [trusted];
+    return [...policies.map((policy) => policy.split(';')
+            .filter((directive) => directive.trim().split(/\s/, 1)[0].toLowerCase() !== 'frame-ancestors')
+            .map((directive) => directive.trim()).filter(Boolean).join('; ')).filter(Boolean), ...frames];
+}
+export function enforceBrowserCachePolicy({ request, response }) {
+    const path = (request.url ?? '/').split('?', 1)[0];
+    let staticAsset = false;
+    try {
+        const segments = path.slice(1).split('/').map((segment) => decodeURIComponent(segment));
+        staticAsset = path.startsWith('/_next/static/') && /\.(?:js|css)$/.test(path) &&
+            segments.every((segment) => segment !== '' && segment !== '.' && segment !== '..' && !/[\\/]/.test(segment));
+    }
+    catch { /* Malformed or ambiguous asset paths retain the default no-store policy. */ }
+    const contentType = response.getHeader('content-type');
+    const mediaType = typeof contentType === 'string' ? contentType.split(';', 1)[0].trim().toLowerCase() : undefined;
+    const assetType = path.endsWith('.css') ? mediaType === 'text/css' : mediaType === 'text/javascript' || mediaType === 'application/javascript';
+    const revalidateAsset = staticAsset && ['GET', 'HEAD'].includes(request.method ?? 'GET') &&
+        (response.statusCode === 200 || response.statusCode === 304) &&
+        (assetType || (response.statusCode === 304 && contentType === undefined));
+    // Every protected reuse must reach authorization. Retain only private static
+    // JS/CSS bytes and validators; app output may never opt into browser/CDN TTLs.
+    for (const name of response.getHeaderNames()) {
+        if (isSharedCacheDirective(name))
+            response.removeHeader(name);
+    }
+    response.setHeader('cache-control', revalidateAsset ? 'private, no-cache' : 'private, no-store');
+    for (const [name, value] of Object.entries(SHARED_CACHE_REFUSAL))
+        response.setHeader(name, value);
+}

package/dist/gateway/usage.d.ts

@@ -1,8 +1,15 @@
 export interface GatewayUsageEvent {
     eventId: string;
     requestId: string;
-    /** The user the gateway acted for: the session owner Atlas authorized for this request. */
+    /**
+     * Who the gateway acted for: the session owner Atlas authorized for this request, or for an
+     * external ingress request the namespaced external subject (`ext|<provider>|<subject>`).
+     */
     actorId: string;
+    /** Present only for an external ingress request. */
+    principalKind?: 'external';
+    /** The ingress an external request arrived through. */
+    ingressId?: string;
     projectId: string;
     deploymentId?: string;
     devSessionId?: string;

package/dist/gateway-main.js

@@ -7,6 +7,7 @@ import { gatewaySessionSameSite } from './gateway/session.js';
 import { RedisTunnelOwnership, RedisTunnelRelay } from './tunnel/redis.js';
 import { ArtifactRequestAdmission } from './gateway/admission.js';
 import { GatewayControlAdmission } from './gateway/control-admission.js';
+import { createIngressRuntime, IngressSecretsError } from './gateway/ingress-runtime.js';
 function required(name) {
     const value = process.env[name];
     if (!value)
@@ -40,6 +41,8 @@ async function main() {
     // A flood of refused requests or forged frames must not become a log flood: count and report every 10 s.
     const refusals = new Map();
     const refuse = (kind) => { refusals.set(kind, (refusals.get(kind) ?? 0) + 1); };
+    // Kinds a caller can produce at request rate: counted, never logged one by one.
+    const counted = new Set(['admission_rejected', 'ingress_pass_rejected', 'ingress_token_rejected', 'ingress_edge_header_invalid', 'ingress_client_ip_invalid']);
     setInterval(() => {
         for (const [kind, count] of refusals)
             log({ event: 'artifact_gateway.request', kind, count });
@@ -56,26 +59,43 @@ async function main() {
     subscriber.on('ready', () => { if (!stopping)
         void relay.start().catch(() => undefined); });
     const controlUrl = required('ARTIFACT_NEXT_CONTROL_PLANE_URL');
+    const controlToken = required('ARTIFACT_NEXT_CONTROL_TOKEN');
+    const control = new ArtifactGatewayControl({ url: controlUrl, token: controlToken });
+    const contextPrivateKey = required('ARTIFACT_NEXT_CONTEXT_PRIVATE_KEY');
+    const contextKeyId = required('ARTIFACT_NEXT_CONTEXT_KEY_ID');
+    const admission = new ArtifactRequestAdmission({ redis: command, namespace });
+    // The external ingress branch: off (every ingress host 404) unless all four of its secrets are
+    // set; the process refuses to boot when they are set but unusable or not independent.
+    const ingress = createIngressRuntime({
+        env: process.env, control, controlToken, sessionKey, contextPrivateKey, contextKeyId, redis: command, namespace, admission, log,
+        onFailure: failure => { if ('count' in failure)
+            log({ event: 'artifact_gateway.request', ...failure });
+        else
+            refuse(failure.kind); },
+    });
     const gateway = createArtifactGateway({
-        control: new ArtifactGatewayControl({ url: controlUrl, token: required('ARTIFACT_NEXT_CONTROL_TOKEN') }),
+        control,
         runtimeDomain: required('ARTIFACT_NEXT_RUNTIME_DOMAIN'),
         parentOrigin: process.env.ARTIFACT_NEXT_PARENT_ORIGIN ?? new URL(controlUrl).origin,
         gatewayOrigin: required('ARTIFACT_NEXT_GATEWAY_URL'),
         sessionKey,
         sessionCookieSameSite: gatewaySessionSameSite({ value: process.env.ARTIFACT_NEXT_SESSION_COOKIE_SAMESITE, appEnv: namespace }),
-        contextPrivateKey: required('ARTIFACT_NEXT_CONTEXT_PRIVATE_KEY'),
-        contextKeyId: required('ARTIFACT_NEXT_CONTEXT_KEY_ID'),
+        contextPrivateKey,
+        contextKeyId,
         nodeId, routing: ownership, relay,
-        admission: new ArtifactRequestAdmission({ redis: command, namespace }),
+        admission,
+        ingress: ingress.ingress,
         controlAdmission: new GatewayControlAdmission({ redis: command, namespace }),
         resolveLease: sessionId => ownership.resolveLease(sessionId),
         renewLease: lease => ownership.renew(lease, nodeId),
         ready: () => clients.every(client => client.status === 'ready') && relay.isReady(),
-        onError: event => { if (event.kind === 'admission_rejected')
+        onError: event => { if (counted.has(event.kind))
             refuse(event.kind);
         else
             log({ event: 'artifact_gateway.request', ...event }); },
     });
+    // The first snapshot pull starts before traffic; until it lands, ingress hosts answer 503.
+    ingress.start();
     const port = Number(process.env.PORT ?? '8080');
     if (!Number.isSafeInteger(port) || port < 1 || port > 65535)
         throw new Error('Invalid gateway PORT');
@@ -102,7 +122,8 @@ async function main() {
         }, 9_000);
         deadline.unref();
         await gateway.drain();
-        await relay.close();
+        // Audit delivery runs beside tunnel cleanup, never in front of it.
+        await Promise.allSettled([ingress.close(), relay.close()]);
         for (const client of clients)
             client.disconnect();
         clearTimeout(deadline);
@@ -110,7 +131,10 @@ async function main() {
     process.once('SIGTERM', () => { void stop(); });
     process.once('SIGINT', () => { void stop(); });
 }
-void main().catch(() => {
-    process.stderr.write(`${JSON.stringify({ event: 'artifact_gateway.start_failed' })}\n`);
+void main().catch((error) => {
+    // Only an ingress-secrets refusal is described: its message names variables, never values, by
+    // construction. Other errors (Redis, URLs) may carry connection strings.
+    const reason = error instanceof IngressSecretsError ? error.message : undefined;
+    process.stderr.write(`${JSON.stringify({ event: 'artifact_gateway.start_failed', ...(reason ? { reason } : {}) })}\n`);
     process.exit(1);
 });

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

@@ -59,11 +59,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 +111,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 +150,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>>;
@@ -291,11 +300,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 +339,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

@@ -47,11 +47,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({

package/dist/manifest.d.ts

@@ -184,11 +184,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 +223,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<{