@sequenceholdings/artifact-studio 0.3.0 → 0.4.0

package/dist/manifest-custom-roles.d.ts

@@ -42,13 +42,23 @@ export declare function customRolesDeclared(block: ArtifactStudioCustomRoles | n
  * manifest's `capabilities.roles.capabilities` record, or already published
  * to the host's registry scope). Roles are never pinned — composition and
  * grants are live runtime configuration owned by the registry.
+ *
+ * `app/<application-id>/<key>` pins a capability an Application defines in
+ * `sequence.app.yml`. It needn't exist yet (members deploy first) and counts
+ * only while the host is a member of that Application.
  */
 export declare const CUSTOM_CAPABILITY_PIN_RE: RegExp;
 export declare const capabilityPinsSchema: z.ZodDefault<z.ZodArray<z.ZodString>>;
-export interface ParsedCapabilityPin {
+export type ParsedCapabilityPin = {
     scope: 'org' | 'project';
     key: string;
 }
+/** An Application capability: live only while the project is a member of `applicationId`. */
+ | {
+    scope: 'app';
+    applicationId: string;
+    key: string;
+};
 /** Split a pin into its scope and key. Assumes the pin grammar validated. */
 export declare function parseCapabilityPin(pin: string): ParsedCapabilityPin;
 /**

package/dist/manifest-custom-roles.js

@@ -158,18 +158,26 @@ export function customRolesDeclared(block) {
  * manifest's `capabilities.roles.capabilities` record, or already published
  * to the host's registry scope). Roles are never pinned — composition and
  * grants are live runtime configuration owned by the registry.
+ *
+ * `app/<application-id>/<key>` pins a capability an Application defines in
+ * `sequence.app.yml`. It needn't exist yet (members deploy first) and counts
+ * only while the host is a member of that Application.
  */
-export const CUSTOM_CAPABILITY_PIN_RE = /^(?:org\/)?[a-z0-9-]+$/;
+export const CUSTOM_CAPABILITY_PIN_RE = /^(?:org\/|app\/[a-z][a-z0-9-]{0,63}\/)?[a-z0-9-]+$/;
 const MAX_CAPABILITY_PINS = 100;
 export const capabilityPinsSchema = z
-    .array(z.string().min(1).max(68).regex(CUSTOM_CAPABILITY_PIN_RE, 'Pins must be "org/<key>" or a bare "<key>" matching [a-z0-9-]+'))
+    .array(z.string().min(1).max(140).regex(CUSTOM_CAPABILITY_PIN_RE, 'Pins must be "org/<key>", "app/<application-id>/<key>", or a bare "<key>" matching [a-z0-9-]+'))
     .max(MAX_CAPABILITY_PINS)
     .default([]);
 /** Split a pin into its scope and key. Assumes the pin grammar validated. */
 export function parseCapabilityPin(pin) {
-    return pin.startsWith('org/')
-        ? { scope: 'org', key: pin.slice('org/'.length) }
-        : { scope: 'project', key: pin };
+    if (pin.startsWith('org/'))
+        return { scope: 'org', key: pin.slice('org/'.length) };
+    if (pin.startsWith('app/')) {
+        const [, applicationId = '', key = ''] = pin.split('/');
+        return { scope: 'app', applicationId, key };
+    }
+    return { scope: 'project', key: pin };
 }
 /**
  * Cross-field pin validation, called from the manifest superRefine (the

package/dist/manifest-next.js

@@ -18,9 +18,21 @@ const apiPath = z.string().min(1).max(512).refine((value) => {
         return false;
     return value.split('/').slice(1).every((part, index, parts) => part !== '.' && part !== '..' && (part !== '' || index === parts.length - 1));
 }, 'API capability paths must be scoped below /api/ without encoded paths, traversal, queries, or fragments');
+// ORM references are what a delegated data token covers (orm-data-plane checkDataTokenScope):
+// a query needs namespace/table for every table it reads, and a mutation needs its
+// namespace/ops/Operation (or table coverage). Any other shape can never match, so it is
+// a typo to report here rather than a 403 at request time. The patterns mirror the ORM's
+// NAMESPACE_PATTERN, IDENTIFIER_PATTERN and GraphQL operation names; they are kept local so
+// browser code that parses manifests does not load the ORM package. platformUsers is the
+// ORM's built-in platform-user entity (PLATFORM_USER_TABLE), a logical key outside the
+// identifier pattern that queries traversing user relations read.
+const ormTableRef = /^[a-z][a-z0-9_]{0,40}\/(?:[a-z][a-z0-9_]{0,62}|platformUsers)$/;
+const ormOperationRef = /^[a-z][a-z0-9_]{0,40}\/ops\/[_A-Za-z][_0-9A-Za-z]*$/;
+const dataReadRef = boundedRef.refine((ref) => ormTableRef.test(ref), 'ORM read references use namespace/table');
+const dataWriteRef = boundedRef.refine((ref) => ormTableRef.test(ref) || ormOperationRef.test(ref), 'ORM write references use namespace/ops/Operation or namespace/table');
 const reachShape = {
     storage: storageScopesSchema.optional(),
-    data: z.strictObject({ read: z.array(boundedRef).max(256).default([]), write: z.array(boundedRef).max(256).default([]) }).prefault({}),
+    data: z.strictObject({ read: z.array(dataReadRef).max(256).default([]), write: z.array(dataWriteRef).max(256).default([]) }).prefault({}),
     api: z.strictObject({ read: z.array(apiPath).max(256).default([]), write: z.array(apiPath).max(256).default([]) }).prefault({}),
     functions: z.strictObject({ invoke: z.array(boundedRef).max(256).default([]) }).prefault({}),
 };

package/dist/next/bridge.js

@@ -103,7 +103,14 @@ export function createNextArtifactBridge(options) {
             if (ready)
                 return ready;
             if (!transport) {
-                transport = createNextArtifactWindowTransport();
+                // Report a missing Atlas parent frame like every other connection failure,
+                // so a caller's promise handler sees it instead of an uncaught throw.
+                try {
+                    transport = createNextArtifactWindowTransport();
+                }
+                catch (error) {
+                    return Promise.reject(error instanceof Error ? error : new Error('Artifact bridge transport unavailable'));
+                }
                 uninstallReleaseGuard = installArtifactReleaseGuard({ deploymentId: bootstrap.deploymentId ?? null });
             }
             ready = new Promise((resolve, reject) => { resolveReady = resolve; rejectReady = reject; });

package/dist/next/protocol.js

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 import { stripArtifactReleaseQuery } from './routes.js';
+import { isLoopbackHostname } from '../loopback.js';
 export const NEXT_ARTIFACT_BRIDGE_TYPE = 'artifact-studio-next';
 export const NEXT_ARTIFACT_BRIDGE_VERSION = 1;
 export const nextArtifactThemeSchema = z.object({
@@ -44,7 +45,7 @@ export function validateNextArtifactBootstrap({ bootstrap }) {
     catch {
         throw new Error('Artifact parent origin must be an exact HTTP(S) origin');
     }
-    const local = parsed.hostname === 'localhost' || parsed.hostname === '127.0.0.1' || parsed.hostname === '[::1]';
+    const local = isLoopbackHostname(parsed.hostname);
     if (parsed.origin !== bootstrap.parentOrigin || (parsed.protocol !== 'https:' && !(parsed.protocol === 'http:' && local))) {
         throw new Error('Artifact parent origin must be HTTPS (or HTTP loopback), without a path');
     }

package/dist/next-cache/config.js

@@ -1,10 +1,12 @@
 import { readFile, readdir, rename, writeFile } from 'node:fs/promises';
-import { join } from 'node:path';
+import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { load as parseYaml } from 'js-yaml';
+import { isNextArtifactManifest, parseArtifactStudioManifest } from '../manifest.js';
 import { resolveArtifactNextImages } from '../next-image-config.js';
 export { artifactNextCacheBindingSchema, verifyArtifactNextCacheReadiness } from './runtime.js';
 const MARKER = '// Generated by Atlas Artifact Studio; original configuration is preserved.';
-function configured(config) {
+function configured(config, egress) {
     const deploymentId = process.env.ARTIFACT_NEXT_BUILD_ID;
     if (deploymentId !== undefined && (deploymentId.length < 1 || deploymentId.length > 128 || /[^A-Za-z0-9_-]/.test(deploymentId)))
         throw new Error('Invalid platform build identifier');
@@ -25,7 +27,6 @@ function configured(config) {
         || Object.entries(handlers).some(([key, value]) => !['default', 'remote'].includes(key) || value !== components))) {
         throw new Error('Artifact Studio owns the Next cacheHandlers configuration');
     }
-    const egress = JSON.parse(process.env.ARTIFACT_NEXT_ALLOWED_EGRESS ?? '[]');
     if (!Array.isArray(egress) || !egress.every((host) => typeof host === 'string'))
         throw new Error('Invalid Artifact image egress policy');
     const images = resolveArtifactNextImages({ images: Reflect.get(config, 'images'), egressHosts: egress });
@@ -34,6 +35,32 @@ function configured(config) {
         cacheHandler: incremental, cacheHandlers: { default: components, remote: components },
         images: { ...images, customCacheHandler: true } };
 }
+/**
+ * seq-studio and the hosted build supply the application's egress policy. A plain local
+ * `next build` or `next dev` reads the same declaration from the application's manifest.
+ */
+async function allowedEgress(config) {
+    const supplied = process.env.ARTIFACT_NEXT_ALLOWED_EGRESS;
+    if (supplied !== undefined)
+        return JSON.parse(supplied);
+    const images = Reflect.get(config, 'images');
+    const patterns = typeof images === 'object' && images !== null ? Reflect.get(images, 'remotePatterns') : undefined;
+    if (process.env.K_SERVICE || !Array.isArray(patterns) || patterns.length === 0)
+        return [];
+    return declaredEgress({ projectRoot: process.cwd() });
+}
+/** The nearest artifact.bundle.yml, when its app_root is this project; the manifest may sit above app_root. */
+async function declaredEgress({ projectRoot }) {
+    for (let directory = projectRoot;; directory = dirname(directory)) {
+        const text = await readFile(join(directory, 'artifact.bundle.yml'), 'utf8').catch(() => undefined);
+        if (text !== undefined) {
+            const manifest = parseArtifactStudioManifest(parseYaml(text));
+            return isNextArtifactManifest(manifest) && resolve(directory, manifest.artifact.app_root) === projectRoot ? manifest.server.egress : [];
+        }
+        if (dirname(directory) === directory)
+            return [];
+    }
+}
 /** Always compiled into standalone output; runtime mode is selected only at boot. */
 export function withArtifactNextConfig(input) {
     return async (phase, context) => {
@@ -48,7 +75,7 @@ export function withArtifactNextConfig(input) {
         const config = typeof input === 'function' ? await input(phase, context) : input;
         if (!config || typeof config !== 'object' || Array.isArray(config))
             throw new Error('Next configuration must return an object');
-        return configured(config);
+        return configured(config, await allowedEgress(config));
     };
 }
 /** Runs only inside the isolated compile sandbox, never in the control-plane worker. */

package/dist/next-dev.js

@@ -14,6 +14,7 @@ import { materializeNextPublicFonts } from './next-public-fonts-local.js';
 import { isTransientNextControlFailure, requestNextDevLease, renewNextDevLease, writeNextRuntimeFile } from './next-dev-control.js';
 import { openNextPreview, selectNextDevPort, startNextDevProcess } from './next-dev-process.js';
 import { connectLocalTunnel } from './tunnel/index.js';
+import { isLocalEnvironmentName } from './loopback.js';
 /** Shutdown never waits longer than this on Atlas; an unconfirmed session still expires with its lease. */
 const SESSION_REVOCATION_TIMEOUT_MS = 10_000;
 export async function runNextDevelopment({ root, manifest, projectId, baseUrl, environment, previewKey, port: requestedPort, links, getToken }) {
@@ -218,7 +219,7 @@ async function runTunnelConnections({ lease: initialLease, environment, port, re
         try {
             const connection = await connectLocalTunnel({
                 url: lease.tunnel.url, token: lease.tunnel.token, sessionId: lease.session.id, epoch: lease.tunnel.epoch,
-                localPort: port, publicOrigin: lease.session.publicOrigin, signal, allowInsecureLoopback: environment === 'local',
+                localPort: port, publicOrigin: lease.session.publicOrigin, signal, allowInsecureLoopback: isLocalEnvironmentName(environment),
             });
             attempt = 0;
             onStatus('ready');

package/dist/next-image-config.js

@@ -66,7 +66,7 @@ function resolveRemotePattern({ pattern, index, egressHosts }) {
         throw new Error(`${label} requires an exact public HTTPS hostname on port 443; wildcard, IP and local hosts are unsupported`);
     }
     if (!egressHosts.includes(value.hostname)) {
-        throw new Error(`${label} hostname must be declared in server.egress; run seq-studio artifact dev/build to supply the application's image policy`);
+        throw new Error(`${label} hostname ${value.hostname} must be declared in the application's server.egress in artifact.bundle.yml`);
     }
     const pathname = remotePatternPathname({ pathname: value.pathname ?? '/**', label });
     const search = remotePatternSearch({ search: value.search, label });

package/dist/next-project.js

@@ -5,6 +5,7 @@ import { join, resolve } from 'node:path';
 import { z } from 'zod';
 import { createScrubbedChildEnv } from './child-environment.js';
 import { ARTIFACT_NEXT_APPROVED_PACKAGES } from './manifest.js';
+import { isLocalEnvironmentName, isLoopbackHostname } from './loopback.js';
 const packageSchema = z.object({
     dependencies: z.record(z.string(), z.string()).default({}),
     devDependencies: z.record(z.string(), z.string()).default({}),
@@ -42,7 +43,7 @@ export async function validateNextProject({ root, manifest, installed, nodeVersi
 }
 export function validateNextPublicOrigin({ value, environment }) {
     const url = new URL(value);
-    const local = environment === 'local' && ['127.0.0.1', 'localhost', '[::1]'].includes(url.hostname);
+    const local = isLocalEnvironmentName(environment) && isLoopbackHostname(url.hostname);
     if ((url.protocol !== 'https:' && !(local && url.protocol === 'http:')) || url.username || url.password || url.search || url.hash || url.pathname !== '/') {
         throw new Error('Atlas returned an invalid application origin; an exact credential-free HTTPS origin is required.');
     }

package/dist/project.js

@@ -9,7 +9,7 @@ import { readNextSourceSnapshot } from './next-source.js';
 import { normalizeArtifactPath } from './paths.js';
 const IGNORED_DIRS = new Set(['node_modules', '.git', 'dist', '.next', '.artifact-studio']);
 const TEXT_EXTENSIONS = new Set([
-    '.ts', '.tsx', '.js', '.jsx', '.json', '.css', '.html', '.md', '.yml', '.yaml', '.svg',
+    '.ts', '.tsx', '.mts', '.cts', '.js', '.jsx', '.mjs', '.cjs', '.json', '.css', '.html', '.md', '.yml', '.yaml', '.svg',
 ]);
 export function hasArtifactStudioManifest(rootDir) {
     return existsSync(join(resolve(rootDir), 'artifact.bundle.yml'));
@@ -83,9 +83,9 @@ function isTextFile(path) {
         TEXT_EXTENSIONS.has(ext));
 }
 function inferContentType(path) {
-    if (path.endsWith('.tsx') || path.endsWith('.ts'))
+    if (/\.(?:tsx?|mts|cts)$/.test(path))
         return 'text/typescript';
-    if (path.endsWith('.jsx') || path.endsWith('.js'))
+    if (/\.(?:jsx?|mjs|cjs)$/.test(path))
         return 'text/javascript';
     if (path.endsWith('.css'))
         return 'text/css';

package/dist/role-definitions-notice.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Capabilities are code, roles are data: roles are created in Atlas, and
+ * `capabilities.roles.definitions` here is a deprecated one-time seed (a
+ * deploy creates any that don't exist yet and never updates them). Atlas only
+ * logs the drift, so tell the author.
+ */
+export declare function warnOnRoleDefinitions(manifest: unknown, warn?: (line: string) => void): void;

package/dist/role-definitions-notice.js

@@ -0,0 +1,19 @@
+/**
+ * Capabilities are code, roles are data: roles are created in Atlas, and
+ * `capabilities.roles.definitions` here is a deprecated one-time seed (a
+ * deploy creates any that don't exist yet and never updates them). Atlas only
+ * logs the drift, so tell the author.
+ */
+export function warnOnRoleDefinitions(manifest, warn = console.warn) {
+    // A non-null, non-array object is safe to index by key; TS can't narrow `object` to a record itself.
+    const record = (value) => typeof value === 'object' && value !== null && !Array.isArray(value) ? value : null;
+    const definitions = record(record(record(record(manifest)?.capabilities)?.roles)?.definitions);
+    if (!definitions)
+        return;
+    const keys = Object.keys(definitions).sort();
+    if (keys.length === 0)
+        return;
+    warn(`[seq-studio] artifact.bundle.yml defines roles (${keys.join(', ')}). Roles in YAML are a deprecated one-time seed: ` +
+        `a deploy creates any that don't exist yet and never updates them after. Create and edit roles in Atlas ` +
+        `(Permissions → Roles); keep capabilities in YAML.`);
+}

package/dist/runtime-contracts.js

@@ -1,6 +1,7 @@
 import { z } from 'zod';
 import { ARTIFACT_NEXT_RUNTIME, artifactNextSecretNameSchema } from './manifest-next.js';
 import { MAX_STUDIO_PATH_LENGTH } from './paths.js';
+import { isLoopbackHostname } from './loopback.js';
 export { resolveArtifactNextImages } from './next-image-config.js';
 /** Shared by local collection, repository collection and the bounded source-upload API. */
 export const ARTIFACT_NEXT_SOURCE_LIMITS = Object.freeze({
@@ -42,7 +43,7 @@ export const artifactSourcePathSchema = z.string().min(1).max(MAX_STUDIO_PATH_LE
 export const artifactRuntimeOriginSchema = z.string().max(2048).refine((value) => {
     try {
         const url = new URL(value);
-        return url.protocol === 'https:' && url.origin === value && !url.hostname.includes('*');
+        return (url.protocol === 'https:' || (url.protocol === 'http:' && isLoopbackHostname(url.hostname))) && url.origin === value && !url.hostname.includes('*');
     }
     catch {
         return false;

package/dist/sandbox-lint.js

@@ -42,7 +42,7 @@ const RULES = [
         message: "Direct fetch() to an external origin is blocked (CSP connect-src 'self') — call Atlas routes via seq.api.fetch.",
     },
 ];
-const LINTABLE_EXTENSIONS = new Set(['.ts', '.tsx', '.js', '.jsx', '.css', '.html']);
+const LINTABLE_EXTENSIONS = new Set(['.ts', '.tsx', '.mts', '.cts', '.js', '.jsx', '.mjs', '.cjs', '.css', '.html']);
 function extensionOf(path) {
     return path.includes('.') ? path.slice(path.lastIndexOf('.')) : '';
 }

package/dist/sdk-orm.d.ts

@@ -0,0 +1,18 @@
+import { type OperationExecutor } from '@sequenceholdings/orm/client';
+import { type SequenceApi } from './sdk.js';
+export interface ArtifactOrmExecutorConfig {
+    namespace: string;
+    /** The generated operations.manifest.json, validated before any host call. */
+    manifest: unknown;
+    /** Optional action-scoped host client (for example, withTraceAction's client). */
+    sdk?: {
+        api: Pick<SequenceApi, 'fetch'>;
+    };
+}
+/**
+ * Execute persisted operations as the signed-in Artifact user. The host owns
+ * authentication; this helper never obtains or exposes browser credentials.
+ * 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;

package/dist/sdk-orm.js

@@ -0,0 +1,21 @@
+import { createOperationExecutorWithTransport, OrmClientError } from '@sequenceholdings/orm/client';
+import { seq } from './sdk.js';
+/**
+ * Execute persisted operations as the signed-in Artifact user. The host owns
+ * authentication; this helper never obtains or exposes browser credentials.
+ * 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 }) {
+    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 },
+        }),
+    });
+}

package/dist/sdk.d.ts

@@ -1,4 +1,5 @@
 import { type StartStorageUpload, type StorageUploadSession } from '@sequenceholdings/storage';
+export { createArtifactOrmExecutor, type ArtifactOrmExecutorConfig } from './sdk-orm.js';
 export interface SequenceStorageOptions {
     signal?: AbortSignal;
     timeoutMs?: number;

package/dist/sdk.js

@@ -1,4 +1,5 @@
 import { storageClient } from '@sequenceholdings/storage';
+export { createArtifactOrmExecutor } from './sdk-orm.js';
 export const seq = typeof window !== 'undefined'
     ? window.seq
     : undefined;

package/dist/server/client.d.ts

@@ -1,5 +1,5 @@
 import { storageClient } from '@sequenceholdings/storage';
-import { type OperationsManifest, type OperationExecutor } from '@sequenceholdings/orm/client';
+import { type OperationExecutor } from '@sequenceholdings/orm/client';
 import type { SequenceApiFetchResponse } from '../sdk.js';
 import { type ArtifactServerMode, type ArtifactServerRequest } from './broker-contract.js';
 import { createArtifactLogger, type ArtifactLogRecord } from './logger.js';
@@ -15,6 +15,20 @@ export interface ArtifactServerFetchOptions {
     body?: unknown;
     signal?: AbortSignal;
 }
+/**
+ * The namespace's generated operations.manifest.json. Only each operation's persisted hash
+ * is read, so the file can be passed as imported: a JSON import types `kind` as string.
+ */
+export interface ArtifactOrmOperations {
+    readonly manifestVersion?: number;
+    readonly schemaHash?: string;
+    readonly opsHash?: string;
+    readonly operations: Readonly<Record<string, {
+        readonly hash: string;
+        readonly kind?: string;
+        readonly requires?: unknown;
+    }>>;
+}
 export interface ArtifactServerClient {
     context: ArtifactRequestContext;
     mode: ArtifactServerMode;
@@ -26,7 +40,7 @@ export interface ArtifactServerClient {
     };
     orm(input: {
         namespace: string;
-        manifest: OperationsManifest;
+        manifest: ArtifactOrmOperations;
     }): OperationExecutor;
     asService(): ArtifactServerClient;
 }

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

@@ -20,6 +20,7 @@ export declare const artifactRequestContextSchema: z.ZodObject<{
     deploymentId: z.ZodNullable<z.ZodString>;
     devSessionId: z.ZodNullable<z.ZodString>;
     requestId: z.ZodString;
+    jti: z.ZodUUID;
     method: z.ZodEnum<{
         GET: "GET";
         POST: "POST";

package/dist/server/request-context.js

@@ -1,5 +1,6 @@
 import { createPublicKey, verify } from 'node:crypto';
 import { z } from 'zod';
+import { isLoopbackHostname } from '../loopback.js';
 export const ARTIFACT_REQUEST_CONTEXT_HEADER = 'x-sequence-artifact-context';
 export const ARTIFACT_RUNTIME_TOKEN_HEADER = 'x-sequence-artifact-runtime';
 export const ARTIFACT_SERVER_REQUEST_PATH = '/api/artifact-studio/server/request';
@@ -9,7 +10,7 @@ const originSchema = z.string().max(2048).refine(value => {
     try {
         const url = new URL(value);
         return value === url.origin && (url.protocol === 'https:' ||
-            (url.protocol === 'http:' && ['localhost', '127.0.0.1', '[::1]'].includes(url.hostname)));
+            (url.protocol === 'http:' && isLoopbackHostname(url.hostname)));
     }
     catch {
         return false;
@@ -26,7 +27,11 @@ export const artifactRequestContextSchema = z.object({
     mode: z.enum(['development', 'preview', 'published']),
     deploymentId: id.nullable(),
     devSessionId: id.nullable(),
+    /** Correlates logs, usage and audit records for the originating request. */
     requestId: id,
+    /** Unique per signed context. Atlas budgets delegated calls per jti until the context expires. */
+    jti: z.uuid(),
+    /** The originating browser request's method. Atlas only delegates reads for GET, HEAD and OPTIONS. */
     method: z.enum(['GET', 'HEAD', 'POST', 'PUT', 'PATCH', 'DELETE', 'OPTIONS']),
     path: z.string().min(1).max(8192).refine(value => value.startsWith('/') &&
         !value.startsWith('//') && !/[\\\r\n\u0000#]/.test(value), 'Expected an origin-relative request path'),

package/dist/server/runtime-config.d.ts

@@ -31,6 +31,7 @@ export declare function getArtifactRequestContext({ headers, runtime, method, pa
     deploymentId: string | null;
     devSessionId: string | null;
     requestId: string;
+    jti: string;
     method: "GET" | "POST" | "DELETE" | "HEAD" | "PUT" | "PATCH" | "OPTIONS";
     path: string;
     iat: number;

package/dist/server/runtime-config.js

@@ -2,11 +2,12 @@ import { constants } from 'node:fs';
 import { open } from 'node:fs/promises';
 import { z } from 'zod';
 import { ARTIFACT_REQUEST_CONTEXT_HEADER, verifyArtifactRequestContext } from './request-context.js';
+import { isLoopbackHostname } from '../loopback.js';
 const atlasOrigin = z.string().refine(value => {
     try {
         const url = new URL(value);
         return value === url.origin && (url.protocol === 'https:' ||
-            (url.protocol === 'http:' && ['localhost', '127.0.0.1', '[::1]'].includes(url.hostname)));
+            (url.protocol === 'http:' && isLoopbackHostname(url.hostname)));
     }
     catch {
         return false;

package/dist/server.d.ts

@@ -1,6 +1,6 @@
 import 'server-only';
 export { createArtifactServerClient, ArtifactServerError } from './server/client.js';
-export type { ArtifactServerClient, ArtifactServerFetchOptions } from './server/client.js';
+export type { ArtifactOrmOperations, ArtifactServerClient, ArtifactServerFetchOptions } from './server/client.js';
 export { getArtifactRequestContext, readArtifactRuntimeConfig } from './server/runtime-config.js';
 export type { ArtifactRuntimeConfig, ArtifactRequestHeaders } from './server/runtime-config.js';
 export { getArtifactBrowserBootstrap } from './server/request-context.js';

package/dist/templates/nextjs/README.md

@@ -71,6 +71,12 @@ only the capabilities the application needs, then configure authorized resource
 bindings in Atlas. Local development uses explicit nonproduction resources and
 never falls back to production when a binding is missing.
 
+ORM access is declared per table and per mutation: list `<namespace>/<table>`
+under `data.read` for every table a query reads (queries that follow
+platform-user relations also read `<namespace>/platformUsers`). Under
+`data.write`, use `<namespace>/ops/<Operation>` for each persisted mutation the
+app runs, or `<namespace>/<table>` for table-level coverage.
+
 Managed secrets stay in hosted runtimes. For local integration tests, use your
 own test credentials, mocks or an existing governed function. Use a hosted
 preview for application code that needs a managed secret. Never put secrets in

package/dist/templates/nextjs/gitignore

@@ -0,0 +1,9 @@
+node_modules/
+.next/
+next-env.d.ts
+.artifact/
+.artifact-studio/
+.env*
+*.tsbuildinfo
+coverage/
+.DS_Store

package/dist/templates/nextjs/pnpm-workspace.yaml

@@ -2,7 +2,21 @@ packages:
   - '.'
 
 minimumReleaseAge: 10080
+# The Sequence SDK chain is published from the Studio repo's audited release
+# pipeline, so a new artifact-studio release must install without waiting out
+# the seven-day quarantine. Scoped to the exact first-party packages a fresh
+# scaffold resolves, not @sequenceholdings/*.
+minimumReleaseAgeExclude:
+  - '@sequenceholdings/artifact-studio'
+  - '@sequenceholdings/atlas-ui'
+  - '@sequenceholdings/custom-roles-manifest'
+  - '@sequenceholdings/lattice-form-renderer'
+  - '@sequenceholdings/orm'
+  - '@sequenceholdings/storage'
 strictDepBuilds: true
 allowBuilds:
   '@tailwindcss/oxide': false
+  # Reached through the SDK's static builder and ORM tooling, never run by a
+  # Next.js app; its platform binary installs as an optional dependency.
+  esbuild: false
   sharp: false

package/dist/templates/react-vite/AGENTS.md

@@ -22,7 +22,7 @@ This is a sandboxed iframe SPA that runs inside Atlas and talks to Atlas backend
 
 ## Prerequisite
 
-None — `seq-studio artifact init <dir>` works from any directory; no monorepo checkout is required. The template lists `@sequenceholdings/artifact-studio` and `@sequenceholdings/atlas-ui` in **devDependencies** for local editor/type-check tooling only. `seq-studio artifact build|deploy` bundles against the CLI's own pinned copies of `react`, `react-dom`, `@tanstack/react-query`, `react-router-dom`, `sonner`, and `@sequenceholdings/atlas-ui`, and resolves `@sequenceholdings/artifact-studio` to a virtual `window.seq` module. Remote deploys (`--repo` / `--git-url`) run `pnpm install --prod` for **app-specific** `dependencies` only (e.g. `recharts`, `reactflow`) from the artifact lockfile.
+None — `seq-studio artifact init <dir>` works from any directory; no monorepo checkout is required. The template lists `@sequenceholdings/artifact-studio` and `@sequenceholdings/atlas-ui` in **devDependencies** for local editor/type-check tooling only. `seq-studio artifact build|deploy` bundles against the CLI's own pinned copies of `react`, `react-dom`, `@tanstack/react-query`, `react-router-dom`, `sonner`, and `@sequenceholdings/atlas-ui`, and resolves `@sequenceholdings/artifact-studio` to the CLI-pinned SDK, whose `seq` export uses the host-injected `window.seq`. The SDK also provides `createArtifactOrmExecutor({ namespace, manifest })` for persisted ORM operations; declare `/api/data/v2/<namespace>` under `capabilities.api.write`, including queries (execution uses POST). The helper handles the ORM envelope; do not pass its result to the CRM `unwrap()` helper. Remote deploys (`--repo` / `--git-url`) run `pnpm install --prod` for **app-specific** `dependencies` only (e.g. `recharts`, `reactflow`) from the artifact lockfile.
 
 ## Package manager
 

package/dist/templates/react-vite/package.json

@@ -9,7 +9,7 @@
   },
   "dependencies": {},
   "devDependencies": {
-    "@sequenceholdings/artifact-studio": "^0.3.0",
+    "@sequenceholdings/artifact-studio": "^0.4.0",
     "@sequenceholdings/atlas-ui": "^3.1.1",
     "@tailwindcss/postcss": "^4.2.2",
     "@tailwindcss/vite": "^4.2.2",