@sequenceholdings/artifact-studio 0.9.0 → 0.9.2

package/dist/next-source-includes.js

@@ -0,0 +1,68 @@
+/**
+ * Source includes: repository directories a Next artifact compiles alongside
+ * its own bundle, such as a generated ORM client several apps share.
+ *
+ * The bundle directory stays the build boundary. An include is read from the
+ * same immutable commit as the bundle, with the same blob, exclusion and size
+ * checks, and placed at a fixed mount inside the app root, so it becomes
+ * ordinary bundle source: hashed into the source hash, compiled from within
+ * the app (no external directories), and invisible to anything not declared.
+ * Apps import it through a tsconfig path alias to the mount; local
+ * development writes the same mount. Never accepted from a local upload,
+ * whose bytes outside the bundle no dirty bit covers.
+ */
+import { z } from 'zod';
+import { isExcludedArtifactSourcePath } from './source-exclusions.js';
+/** Where includes are placed, relative to app_root. Reserved when any include is declared. */
+export const SOURCE_INCLUDE_MOUNT = '.artifact-includes';
+export const MAX_SOURCE_INCLUDES = 4;
+const includePath = z.string().min(1).max(512).refine((value) => !value.startsWith('/') && !/[\\:\s\x00-\x1f]/.test(value) &&
+    value.split('/').every((part) => part !== '' && part !== '.' && part !== '..' && !part.startsWith('.') && part !== 'node_modules') &&
+    !isExcludedArtifactSourcePath({ path: value }), 'Source include paths must be repository-relative directories without traversal, hidden directories, or excluded segments');
+export const artifactNextSourceIncludeSchema = z.strictObject({ path: includePath });
+const isWithin = ({ path, root }) => path === root || path.startsWith(`${root}/`);
+export const artifactNextSourceIncludesSchema = z.array(artifactNextSourceIncludeSchema).max(MAX_SOURCE_INCLUDES).superRefine((includes, ctx) => {
+    includes.forEach((include, index) => {
+        const overlap = includes.findIndex((other, otherIndex) => otherIndex !== index && isWithin({ path: include.path, root: other.path }));
+        if (overlap !== -1)
+            ctx.addIssue({ code: 'custom', path: [index, 'path'], message: `${include.path} overlaps ${includes[overlap]?.path}; declare each directory once` });
+    });
+}).default([]);
+export function sourceIncludeMountRoot({ appRoot }) {
+    return appRoot === '.' ? SOURCE_INCLUDE_MOUNT : `${appRoot}/${SOURCE_INCLUDE_MOUNT}`;
+}
+/**
+ * Which repository files each include contributes and where they mount.
+ * `paths` are repository-relative file paths at the build commit; `sourceRoot`
+ * is the bundle directory. Throws for an include that overlaps the bundle or
+ * contributes nothing.
+ */
+export function planSourceIncludes({ includes, sourceRoot, appRoot, paths }) {
+    if (includes.length === 0)
+        return [];
+    if (sourceRoot === '.')
+        throw new Error('Source includes are unavailable to a bundle at the repository root; its whole tree is already the bundle');
+    const mount = sourceIncludeMountRoot({ appRoot });
+    const planned = [];
+    for (const { path: root } of includes) {
+        if (isWithin({ path: root, root: sourceRoot }))
+            throw new Error(`Source include ${root} is already inside the bundle ${sourceRoot}`);
+        if (isWithin({ path: sourceRoot, root }))
+            throw new Error(`Source include ${root} contains the bundle ${sourceRoot}`);
+        const files = paths
+            .filter((path) => path.startsWith(`${root}/`) && !isExcludedArtifactSourcePath({ path: path.slice(root.length + 1) }))
+            .sort();
+        if (files.length === 0)
+            throw new Error(`Source include ${root} contains no source files at this commit`);
+        for (const repositoryPath of files)
+            planned.push({ repositoryPath, sourcePath: `${mount}/${repositoryPath}` });
+    }
+    return planned;
+}
+/** A bundle that declares includes may not commit its own files under the mount they own. */
+export function assertNoReservedSourcePaths({ appRoot, paths }) {
+    const mount = sourceIncludeMountRoot({ appRoot });
+    const reserved = paths.find((path) => isWithin({ path, root: mount }));
+    if (reserved)
+        throw new Error(`${reserved} is under ${mount}, which is reserved for source includes; remove it from the commit (keep the local copy ignored)`);
+}

package/dist/prepare-build.d.ts

@@ -14,14 +14,22 @@ export declare function extractChainguardAuthLines(userNpmrc: string): string[];
 /** Merge trusted Chainguard auth from ~/.npmrc with pinned install settings. */
 export declare function buildControlledArtifactNpmrc(userNpmrcPath?: string): string;
 export interface PrepareBuildOptions {
-    /** Remote sources (--repo / --git-url) install when package.json exists. */
+    /** Remote sources (--repo / --git-url) install the production dependencies package.json declares. */
     remote?: boolean;
+    /**
+     * Set by an embedder whose host cannot reach a package registry, such as an
+     * agent sandbox. A remote source that needs an install fails with this
+     * guidance instead of attempting one.
+     */
+    installUnavailable?: string;
     /** Parent environment override for deterministic security tests. */
     sourceEnv?: NodeJS.ProcessEnv;
 }
 /**
  * Whether the build should run `pnpm install` before Vite bundles the tree.
- * Only remote materializations (--repo / --git-url) are bare and need install.
+ * Only remote materializations (--repo / --git-url) are bare, and only
+ * production dependencies need installing: the build aliases every scaffold
+ * import (react, atlas-ui, react-query, the SDK) to this package's pinned copies.
  */
 export declare function shouldInstallArtifactDependencies(dir: string, opts?: PrepareBuildOptions): boolean;
 /**

package/dist/prepare-build.js

@@ -46,14 +46,35 @@ export function buildControlledArtifactNpmrc(userNpmrcPath = join(homedir(), '.n
     }
     return `${authBlock}${ARTIFACT_BUILD_NPMRC}`;
 }
+/** The package.json fields `pnpm install --prod` installs. devDependencies never reach a build. */
+const INSTALLED_DEPENDENCY_FIELDS = ['dependencies', 'optionalDependencies'];
+function declaresInstalledDependencies(packageJsonPath) {
+    let manifest;
+    try {
+        manifest = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
+    }
+    catch (error) {
+        throw new Error(`package.json is not valid JSON: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    if (typeof manifest !== 'object' || manifest === null || Array.isArray(manifest)) {
+        throw new Error('package.json must be a JSON object.');
+    }
+    return INSTALLED_DEPENDENCY_FIELDS.some((field) => {
+        const value = Reflect.get(manifest, field);
+        return typeof value === 'object' && value !== null && Object.keys(value).length > 0;
+    });
+}
 /**
  * Whether the build should run `pnpm install` before Vite bundles the tree.
- * Only remote materializations (--repo / --git-url) are bare and need install.
+ * Only remote materializations (--repo / --git-url) are bare, and only
+ * production dependencies need installing: the build aliases every scaffold
+ * import (react, atlas-ui, react-query, the SDK) to this package's pinned copies.
  */
 export function shouldInstallArtifactDependencies(dir, opts = {}) {
     if (!opts.remote)
         return false;
-    return existsSync(join(dir, 'package.json'));
+    const packageJsonPath = join(dir, 'package.json');
+    return existsSync(packageJsonPath) && declaresInstalledDependencies(packageJsonPath);
 }
 /**
  * Install artifact runtime deps into the build root. Platform peers (react,
@@ -61,8 +82,17 @@ export function shouldInstallArtifactDependencies(dir, opts = {}) {
  * time — this step resolves app-specific imports like recharts or reactflow.
  */
 export async function prepareArtifactBuildRoot(dir, opts = {}) {
-    if (!shouldInstallArtifactDependencies(dir, opts))
+    if (!opts.remote)
+        return;
+    if (!shouldInstallArtifactDependencies(dir, opts)) {
+        // Nothing to install, but a node_modules committed into the checkout must
+        // still never resolve imports for the build (see the install path below).
+        await rm(join(dir, 'node_modules'), { recursive: true, force: true });
         return;
+    }
+    if (opts.installUnavailable) {
+        throw new Error(`This artifact declares production dependencies (package.json dependencies or optionalDependencies), which install from the package registry. ${opts.installUnavailable}`);
+    }
     if (!existsSync(join(dir, 'pnpm-lock.yaml'))) {
         throw new Error('Remote artifact deploy requires pnpm-lock.yaml — run `pnpm install` locally and commit the lockfile.');
     }

package/dist/repository-identity.d.ts

@@ -0,0 +1,31 @@
+import { z } from 'zod';
+/** Internal wire contract shared by Atlas and seq-studio. Not deployment authorization. */
+export declare const REPOSITORY_IDENTITY_PATH = ".seq/identity.json";
+export declare const RepositoryIdentitySchema: z.ZodObject<{
+    tenantId: z.ZodString;
+    repositoryId: z.ZodString;
+    generation: z.ZodNumber;
+}, z.core.$strict>;
+export type RepositoryIdentity = z.infer<typeof RepositoryIdentitySchema>;
+export declare const RepositoryReceiptSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    identity: z.ZodObject<{
+        tenantId: z.ZodString;
+        repositoryId: z.ZodString;
+        generation: z.ZodNumber;
+    }, z.core.$strict>;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+}, z.core.$strict>;
+export type RepositoryReceipt = z.infer<typeof RepositoryReceiptSchema>;
+export declare function parseRepositoryReceipt({ text }: {
+    text: string;
+}): RepositoryReceipt;
+export declare function renderRepositoryReceipt({ identity, metadata }: {
+    identity: RepositoryIdentity;
+    metadata?: RepositoryReceipt['metadata'];
+}): string;
+export declare function assertRepositoryIdentity({ receipt, expected }: {
+    receipt: RepositoryReceipt;
+    /** Must come from the authenticated platform record, never from the receipt itself. */
+    expected: RepositoryIdentity;
+}): void;

package/dist/repository-identity.js

@@ -0,0 +1,41 @@
+import { z } from 'zod';
+/** Internal wire contract shared by Atlas and seq-studio. Not deployment authorization. */
+export const REPOSITORY_IDENTITY_PATH = '.seq/identity.json';
+export const RepositoryIdentitySchema = z.object({
+    tenantId: z.string().max(32).regex(/^[a-z][a-z0-9]*(?:_[a-z0-9]+)*$/),
+    repositoryId: z.string().uuid(),
+    generation: z.number().int().positive().max(Number.MAX_SAFE_INTEGER),
+}).strict();
+export const RepositoryReceiptSchema = z.object({
+    schemaVersion: z.literal(1),
+    identity: RepositoryIdentitySchema,
+    // Extensible, non-authoritative annotations. Never use metadata for auth or routing.
+    metadata: z.record(z.string(), z.json()).default({}),
+}).strict();
+export function parseRepositoryReceipt({ text }) {
+    if (new TextEncoder().encode(text).byteLength > 65_536)
+        throw new Error('Repository identity exceeds 64 KiB');
+    const value = JSON.parse(text);
+    const visit = (entry, depth) => {
+        if (depth > 32)
+            throw new Error('Repository identity exceeds the metadata depth limit');
+        if (entry !== null && typeof entry === 'object') {
+            for (const child of Object.values(entry))
+                visit(child, depth + 1);
+        }
+    };
+    visit(value, 0);
+    return RepositoryReceiptSchema.parse(value);
+}
+export function renderRepositoryReceipt({ identity, metadata = {} }) {
+    const text = JSON.stringify({ schemaVersion: 1, identity, metadata }, null, 2) + '\n';
+    parseRepositoryReceipt({ text });
+    return text;
+}
+export function assertRepositoryIdentity({ receipt, expected }) {
+    if (receipt.identity.tenantId !== expected.tenantId ||
+        receipt.identity.repositoryId !== expected.repositoryId ||
+        receipt.identity.generation !== expected.generation) {
+        throw new Error('Repository identity does not match the platform record; do not edit identity fields to change ownership');
+    }
+}

package/dist/runtime-contracts.d.ts

@@ -17,10 +17,7 @@ export declare const ARTIFACT_NEXT_SOURCE_LIMITS: Readonly<{
 export declare const artifactSha256DigestSchema: z.ZodString;
 /** Immutable Next deploymentId from compiled output; distinct from the Atlas activation ID. */
 export declare const artifactNextFrameworkBuildIdSchema: z.ZodString;
-/** Shared upload exclusion policy. Content scanning and filesystem containment remain separate checks. */
-export declare function isExcludedArtifactSourcePath({ path }: {
-    path: string;
-}): boolean;
+export { isExcludedArtifactSourcePath } from './source-exclusions.js';
 /** POSIX source paths only; filesystem readers must additionally reject symlink escapes. */
 export declare const artifactSourcePathSchema: z.ZodString;
 /** An exact browser origin, not a URL prefix or an allowlist wildcard. */

package/dist/runtime-contracts.js

@@ -2,6 +2,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';
+import { isExcludedArtifactSourcePath } from './source-exclusions.js';
 export { resolveArtifactNextImages } from './next-image-config.js';
 /** Atlas routes the gateway calls; every one authenticates the gateway itself. */
 export const ARTIFACT_NEXT_CONTROL_PATH = '/api/artifact-studio/next/control';
@@ -27,21 +28,7 @@ export const artifactSha256DigestSchema = z.string().regex(/^[a-f0-9]{64}$/, 'Ex
 export const artifactNextFrameworkBuildIdSchema = z.string().min(1).max(128).refine((value) => !/[^A-Za-z0-9_-]/.test(value), 'Expected a canonical Next.js deploymentId containing only letters, digits, underscores and hyphens');
 const imageDigestSchema = z.string().regex(/^sha256:[a-f0-9]{64}$/, 'Expected a SHA-256 image digest');
 const imageReferenceSchema = z.string().max(1024).regex(/^[a-z0-9]+(?:[.-][a-z0-9]+)*(?::[1-9][0-9]{0,4})?(?:\/[a-z0-9]+(?:[._-][a-z0-9]+)*)+@sha256:[a-f0-9]{64}$/, 'Expected a registry image reference pinned by digest');
-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', '.seq-next-output.json',
-]);
-/** Shared upload exclusion policy. Content scanning and filesystem containment remain separate checks. */
-export function isExcludedArtifactSourcePath({ path }) {
-    return path.split('/').some((segment) => {
-        const normalized = segment.toLowerCase();
-        return excludedSourceSegments.has(normalized)
-            || normalized.startsWith('.env') || normalized.startsWith('.yarnrc')
-            || /(?:^|[-_.])(?:credentials?|service[-_]?account)(?:[-_.].*)?\.json$/.test(normalized)
-            || /\.(pem|key|p12|pfx|jks)$/.test(normalized);
-    });
-}
+export { isExcludedArtifactSourcePath } from './source-exclusions.js';
 /** POSIX source paths only; filesystem readers must additionally reject symlink escapes. */
 export const artifactSourcePathSchema = z.string().min(1).max(MAX_STUDIO_PATH_LENGTH).refine((path) => {
     if (path !== path.trim() || /[\\%:\u0000-\u001f\u007f]/.test(path))

package/dist/source-boundary.d.ts

@@ -4,16 +4,37 @@ export interface ArtifactSourceBoundaryOptions {
     trustedExternalRoots: readonly string[];
 }
 /**
- * Artifact source must be self-contained: allowing a relative import to escape
- * the build root would let uncommitted files elsewhere in a containing
- * checkout enter the official bundle without being covered by its dirty bit.
- * Published dependencies and the CLI-pinned platform peers are intentionally
- * allowed because they are external to the artifact by design.
+ * Which files may feed an artifact build. Artifact source must be
+ * self-contained: a relative path that escapes the build root would let files
+ * elsewhere on the build machine (uncommitted checkout files, or the caller's
+ * credentials) enter the official bundle. Published dependencies and the
+ * CLI-pinned platform peers are intentionally allowed because they are external
+ * to the artifact by design.
  */
-export declare function rejectOutsideSourcePlugin({ root, trustedExternalRoots, }: ArtifactSourceBoundaryOptions): Plugin;
+export interface SourceBoundary {
+    /** Physical source root. */
+    root: string;
+    /**
+     * Throw unless `filePath` may enter the build when `importer` references it.
+     * `bareSpecifier` marks a package reference rather than a path. Paths are
+     * compared physically, so an in-root symlink cannot admit an outside file.
+     */
+    assertBuildInput(input: {
+        filePath: string;
+        importer?: string;
+        bareSpecifier: boolean;
+        reference: string;
+    }): void;
+    /** Whether `filePath` is part of the CLI-pinned platform toolchain. */
+    isTrusted(filePath: string): boolean;
+}
+export declare function createSourceBoundary({ root, trustedExternalRoots }: ArtifactSourceBoundaryOptions): SourceBoundary;
+/** Reject module imports that resolve outside the source boundary. */
+export declare function rejectOutsideSourcePlugin(boundary: SourceBoundary): Plugin;
 /**
  * Whether `filePath` is inside a `node_modules` directory. Bundlers pass
  * Windows paths with forward slashes, so compare in that form whatever the
  * platform separator is.
  */
 export declare function isNodeModulesPath(filePath: string): boolean;
+export declare function isBareImport(source: string): boolean;

package/dist/source-boundary.js

@@ -1,15 +1,46 @@
 import { realpathSync } from 'node:fs';
-import { isAbsolute, relative, resolve, sep } from 'node:path';
-/**
- * Artifact source must be self-contained: allowing a relative import to escape
- * the build root would let uncommitted files elsewhere in a containing
- * checkout enter the official bundle without being covered by its dirty bit.
- * Published dependencies and the CLI-pinned platform peers are intentionally
- * allowed because they are external to the artifact by design.
- */
-export function rejectOutsideSourcePlugin({ root, trustedExternalRoots, }) {
+import { basename, dirname, isAbsolute, join, relative, resolve, sep } from 'node:path';
+export function createSourceBoundary({ root, trustedExternalRoots }) {
     const rootResolved = realpathSync(resolve(root));
     const trustedRoots = trustedExternalRoots.map((trustedRoot) => realpathSync(resolve(trustedRoot)));
+    const isTrusted = (filePath) => isTrustedExternalPath(physicalPath(filePath), trustedRoots);
+    return {
+        root: rootResolved,
+        isTrusted,
+        assertBuildInput({ filePath, importer, bareSpecifier, reference }) {
+            const realFilePath = physicalPath(filePath);
+            if (isPathWithin(rootResolved, realFilePath))
+                return;
+            const importerPath = importer?.split('?')[0];
+            const importerIsTrustedExternal = importerPath != null &&
+                (isNodeModulesPath(importerPath) || (isAbsolute(importerPath) && isTrusted(importerPath)));
+            if (isNodeModulesPath(filePath) && (bareSpecifier || importerIsTrustedExternal))
+                return;
+            if (isTrustedExternalPath(realFilePath, trustedRoots))
+                return;
+            const from = importerPath ? ` (referenced from ${relative(rootResolved, importerPath)})` : '';
+            throw new Error(`Artifact ${reference} "${filePath}" resolves outside artifact source directory ` +
+                `"${rootResolved}"${from}. Keep relative build inputs inside the artifact ` +
+                'source directory or publish shared code as a dependency.');
+        },
+    };
+}
+/**
+ * The realpath of `filePath`, or of its deepest existing ancestor joined with
+ * the rest, so a reference to a file that does not exist yet is still compared
+ * physically.
+ */
+function physicalPath(filePath) {
+    try {
+        return realpathSync(filePath);
+    }
+    catch {
+        const parent = dirname(filePath);
+        return parent === filePath ? filePath : join(physicalPath(parent), basename(filePath));
+    }
+}
+/** Reject module imports that resolve outside the source boundary. */
+export function rejectOutsideSourcePlugin(boundary) {
     return {
         name: 'reject-artifact-outside-source',
         enforce: 'pre',
@@ -21,26 +52,9 @@ export function rejectOutsideSourcePlugin({ root, trustedExternalRoots, }) {
             if (!isAbsolute(filePath))
                 return resolved;
             // Vite may return a physical path for a root reached through /tmp or
-            // another symlink. Check physical paths on both sides of the boundary;
-            // this also prevents an in-root symlink from admitting an outside file.
-            const realFilePath = realpathSync(filePath);
-            if (isPathWithin(rootResolved, realFilePath))
-                return resolved;
-            const importerPath = importer?.split('?')[0];
-            const importerIsTrustedExternal = importerPath != null &&
-                (isNodeModulesPath(importerPath) ||
-                    (isAbsolute(importerPath) && isTrustedExternalPath(realpathSync(importerPath), trustedRoots)));
-            if (isNodeModulesPath(filePath) && (isBareImport(source) || importerIsTrustedExternal)) {
-                return resolved;
-            }
-            if (isTrustedExternalPath(realFilePath, trustedRoots))
-                return resolved;
-            const from = importer
-                ? ` (imported from ${relative(rootResolved, importer.split('?')[0])})`
-                : '';
-            throw new Error(`Artifact import "${filePath}" resolves outside artifact source directory ` +
-                `"${rootResolved}"${from}. Keep relative build inputs inside the artifact ` +
-                'source directory or publish shared code as a dependency.');
+            // another symlink; the boundary compares physical paths on both sides.
+            boundary.assertBuildInput({ filePath, importer, bareSpecifier: isBareImport(source), reference: 'import' });
+            return resolved;
         },
     };
 }
@@ -62,6 +76,6 @@ function isTrustedExternalPath(filePath, trustedRoots) {
 export function isNodeModulesPath(filePath) {
     return filePath.replaceAll('\\', '/').includes('/node_modules/');
 }
-function isBareImport(source) {
+export function isBareImport(source) {
     return !source.startsWith('.') && !isAbsolute(source);
 }

package/dist/source-exclusions.d.ts

@@ -0,0 +1,4 @@
+/** Shared upload exclusion policy. Content scanning and filesystem containment remain separate checks. */
+export declare function isExcludedArtifactSourcePath({ path }: {
+    path: string;
+}): boolean;

package/dist/source-exclusions.js

@@ -0,0 +1,16 @@
+/** Leaf module (no imports) so manifest and source-include validation can share it without a cycle. */
+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', '.seq-next-output.json',
+]);
+/** Shared upload exclusion policy. Content scanning and filesystem containment remain separate checks. */
+export function isExcludedArtifactSourcePath({ path }) {
+    return path.split('/').some((segment) => {
+        const normalized = segment.toLowerCase();
+        return excludedSourceSegments.has(normalized)
+            || normalized.startsWith('.env') || normalized.startsWith('.yarnrc')
+            || /(?:^|[-_.])(?:credentials?|service[-_]?account)(?:[-_.].*)?\.json$/.test(normalized)
+            || /\.(pem|key|p12|pfx|jks)$/.test(normalized);
+    });
+}

package/dist/source-resolver.js

@@ -4,7 +4,7 @@ import { mkdtemp, realpath, rm, stat } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { isAbsolute, join, relative, resolve, sep } from 'node:path';
 import { createScrubbedChildEnv } from './child-environment.js';
-import { materializeRepo, resolveCommitSha, resolveRepo } from './git-service-client.js';
+import { checkRepositoryDeploymentIdentity, materializeRepo, resolveCommitSha, resolveRepo } from './git-service-client.js';
 import { gitServiceCloneUrl, runGitClone } from './git-clone.js';
 /** True for sources that must be fetched from a remote (git-service / git-url). */
 export function isRemoteSpec(spec) {
@@ -126,6 +126,7 @@ export async function resolveArtifactSource(spec, opts = {}) {
             const repo = await resolveRepo({ baseUrl: opts.baseUrl, token: opts.token, namespace: spec.namespace, name: spec.name });
             const ref = spec.ref ?? repo.defaultBranch;
             const sha = await resolveCommitSha({ baseUrl: opts.baseUrl, token: opts.token, repoId: repo.id, ref });
+            await checkRepositoryDeploymentIdentity({ baseUrl: opts.baseUrl, token: opts.token, repoId: repo.id, commit: sha });
             // CI/system path: the trusted M2M service account can't own a PAT (PAT
             // issuance is gated on a human Auth0 user row), so it keeps the JSON
             // materialize path it has always used, authenticated by its M2M token.

package/package.json

@@ -9,7 +9,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.9.0",
+  "version": "0.9.2",
   "description": "SDK types and CLI library for building Artifact Studio apps. Driven via `seq-studio artifact <sub>` (@sequenceholdings/studio-cli), which runs the `./cli` runCli export.",
   "type": "module",
   "exports": {
@@ -33,6 +33,10 @@
       "types": "./dist/git-service-client.d.ts",
       "default": "./dist/git-service-client.js"
     },
+    "./repository-identity": {
+      "types": "./dist/repository-identity.d.ts",
+      "default": "./dist/repository-identity.js"
+    },
     "./git-clone": {
       "types": "./dist/git-clone.d.ts",
       "default": "./dist/git-clone.js"
@@ -168,8 +172,8 @@
     "server-only": "0.0.1",
     "parse5": "7.3.0",
     "@sequenceholdings/lattice-form-renderer": "0.2.0",
-    "@sequenceholdings/storage": "0.1.1",
-    "@sequenceholdings/orm": "2.6.2"
+    "@sequenceholdings/orm": "2.6.2",
+    "@sequenceholdings/storage": "0.1.2"
   },
   "devDependencies": {
     "@types/js-yaml": "^4.0.9",