@nomix-ai/nomix-harness 0.2.4 → 0.2.6

package/dist/kernel/app-boot/lib/types/profile.d.ts

@@ -16,13 +16,13 @@
  * first from the nomix installation (the launcher's own package), then from the
  * profile directory. The Loader's `baseUrl` is the profile directory, whose
  * `node_modules` pnpm manages for out-of-tree plugins, while the maintained
- * flat fallback directory `$NOMIX_HOME/profiles/node_modules` links both the
- * installation's dependency closure and aggregate-package kernel entries,
- * making every in-box plugin Node-resolvable through the ordinary parent-walk.
+ * flat fallback directory `$NOMIX_HOME/profiles/node_modules` (one symlink per
+ * package the installation's app and bundles depend on) makes every in-box
+ * plugin Node-resolvable from any profile through the ordinary parent-walk.
  * @module @nomix-ai/nomix-app-boot/profile
  */
-import type { EntryOptions } from '@nomix-ai/cordis-plugin-loader';
-import { type PatchOptions } from '@nomix-ai/cordis-plugin-include';
+import type { EntryOptions } from '../../../cordis-plugin-loader/lib/index.js';
+import { type PatchOptions } from '../../../cordis-plugin-include/lib/index.js';
 /** Directory under the Harness home holding every profile. */
 export declare const PROFILES_DIR = "profiles";
 /** The user patch layer inside a profile directory (hot-reloaded on long-lived surfaces). */
@@ -98,15 +98,18 @@ export declare const DEFAULT_PROFILE_BUNDLES: readonly string[];
  */
 export declare function initProfile(dir: string, bundles: readonly string[]): void;
 /**
- * Maintain the flat module fallback `$NOMIX_HOME/profiles/node_modules`. It
- * links the nomix app's resolvable dependency closure and every package listed
- * by an aggregate distribution's `dist/kernel/manifest.json`. Node's
- * parent-directory walk from any profile therefore resolves in-box plugins
- * without pnpm managing them. The dependency closure is required for
- * out-of-tree plugin peers; the kernel manifest supplies package identities
- * that are embedded rather than installed as standalone npm dependencies.
- * Symlinked packages resolve their own dependencies from their real
- * directories, so each package needs only one flat link.
+ * Maintain the flat module fallback `$NOMIX_HOME/profiles/node_modules`: one
+ * symlink per package in the nomix app's resolvable dependency CLOSURE (BFS
+ * over `dependencies` from the app manifest), each resolved from its own
+ * real location. Node's parent-directory walk from any profile finds this
+ * directory after the profile's own `node_modules`, so every in-box plugin
+ * resolves without pnpm ever managing it — the exact "bundles come from the
+ * installation" contract. The closure (not just direct dependencies) is
+ * required for out-of-tree plugins: their peer dependencies name Service
+ * Definition packages (`nomix-compaction`, `nomix-invariants`, ...) that the app
+ * reaches only through its Service Provider packages. Symlinked packages
+ * resolve their own dependencies from their real directories (Node's default
+ * symlink-following), so each package needs only its one flat link.
  * Idempotent: correct links are kept and moved installations are
  * re-pointed; a stale link to a vanished package stays until its name is
  * reused (dangling links are invisible to resolution).

package/dist/kernel/app-boot/lib/types/profile.js

@@ -16,17 +16,16 @@
  * first from the nomix installation (the launcher's own package), then from the
  * profile directory. The Loader's `baseUrl` is the profile directory, whose
  * `node_modules` pnpm manages for out-of-tree plugins, while the maintained
- * flat fallback directory `$NOMIX_HOME/profiles/node_modules` links both the
- * installation's dependency closure and aggregate-package kernel entries,
- * making every in-box plugin Node-resolvable through the ordinary parent-walk.
+ * flat fallback directory `$NOMIX_HOME/profiles/node_modules` (one symlink per
+ * package the installation's app and bundles depend on) makes every in-box
+ * plugin Node-resolvable from any profile through the ordinary parent-walk.
  * @module @nomix-ai/nomix-app-boot/profile
  */
 import { createRequire } from 'node:module';
 import { existsSync, lstatSync, mkdirSync, readFileSync, readlinkSync, symlinkSync, unlinkSync, writeFileSync, } from 'node:fs';
 import { basename, dirname, isAbsolute, join, relative, resolve, sep } from 'node:path';
-import { applyEntryPatches } from '@nomix-ai/cordis-plugin-include';
+import { applyEntryPatches } from '../../../cordis-plugin-include/lib/index.js';
 import { resolveNomixHome } from '../../../home-paths/lib/index.js';
-import { rejectLegacyManifestSection } from "./legacy-branding.js";
 import { loadOverlayPatches } from "./index.js";
 /** Directory under the Harness home holding every profile. */
 export const PROFILES_DIR = 'profiles';
@@ -136,15 +135,18 @@ function ensureSymlink(link, target) {
     }
 }
 /**
- * Maintain the flat module fallback `$NOMIX_HOME/profiles/node_modules`. It
- * links the nomix app's resolvable dependency closure and every package listed
- * by an aggregate distribution's `dist/kernel/manifest.json`. Node's
- * parent-directory walk from any profile therefore resolves in-box plugins
- * without pnpm managing them. The dependency closure is required for
- * out-of-tree plugin peers; the kernel manifest supplies package identities
- * that are embedded rather than installed as standalone npm dependencies.
- * Symlinked packages resolve their own dependencies from their real
- * directories, so each package needs only one flat link.
+ * Maintain the flat module fallback `$NOMIX_HOME/profiles/node_modules`: one
+ * symlink per package in the nomix app's resolvable dependency CLOSURE (BFS
+ * over `dependencies` from the app manifest), each resolved from its own
+ * real location. Node's parent-directory walk from any profile finds this
+ * directory after the profile's own `node_modules`, so every in-box plugin
+ * resolves without pnpm ever managing it — the exact "bundles come from the
+ * installation" contract. The closure (not just direct dependencies) is
+ * required for out-of-tree plugins: their peer dependencies name Service
+ * Definition packages (`nomix-compaction`, `nomix-invariants`, ...) that the app
+ * reaches only through its Service Provider packages. Symlinked packages
+ * resolve their own dependencies from their real directories (Node's default
+ * symlink-following), so each package needs only its one flat link.
  * Idempotent: correct links are kept and moved installations are
  * re-pointed; a stale link to a vanished package stays until its name is
  * reused (dangling links are invisible to resolution).
@@ -189,7 +191,7 @@ export function healProfilesModuleFallback(installAnchor, home = resolveNomixHom
             throw new Error('nomix: packaged kernel manifest must hold a JSON object');
         }
         for (const [packageName, targetRelative] of Object.entries(packaged)) {
-            if (!packageName.startsWith('@nomix-ai/nomix-') || typeof targetRelative !== 'string') {
+            if (!packageName.startsWith('@nomix-ai/') || typeof targetRelative !== 'string') {
                 throw new Error(`nomix: invalid packaged kernel manifest entry ${JSON.stringify(packageName)}`);
             }
             const target = resolve(kernelRoot, targetRelative);
@@ -234,7 +236,6 @@ export function readProfileManifest(binName, dir) {
     if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
         throw new Error(`${binName}: profile manifest ${path} must hold a JSON object`);
     }
-    rejectLegacyManifestSection(parsed, path);
     return parsed;
 }
 /**
@@ -288,14 +289,6 @@ function packageDirFromAnchor(anchor, packageName) {
     }
     return undefined;
 }
-/** Resolve a bundle embedded in the aggregate npm package, if present. */
-function packagedBundleDir(installAnchor, packageName) {
-    const prefix = '@nomix-ai/nomix-';
-    if (!packageName.startsWith(prefix))
-        return undefined;
-    const candidate = join(dirname(installAnchor), 'dist', 'bundles', packageName.slice(prefix.length));
-    return existsSync(join(candidate, 'package.json')) ? candidate : undefined;
-}
 /**
  * Resolve one bundle package's directory: installation anchor first, then the
  * profile directory. The installation-first order is the contract that
@@ -309,9 +302,6 @@ function packagedBundleDir(installAnchor, packageName) {
  * @returns the bundle package's absolute directory.
  */
 export function resolveBundleDir(binName, packageName, installAnchor, profileDir) {
-    const packaged = packagedBundleDir(installAnchor, packageName);
-    if (packaged !== undefined)
-        return packaged;
     for (const anchor of [installAnchor, join(profileDir, 'package.json')]) {
         const dir = packageDirFromAnchor(anchor, packageName);
         if (dir !== undefined)

package/dist/kernel/app-boot/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@nomix-ai/nomix-app-boot",
   "description": "Shared boot glue for the app bins: .env loading, fail-loud Loader guards, snapshot-aware config resolution, and the Loader boot sequence",
-  "version": "0.2.4",
+  "version": "0.2.6",
   "publishConfig": {
     "access": "public"
   },

package/dist/kernel/atomic-write/lib/index.js

@@ -1,5 +1,5 @@
 import { randomBytes } from "node:crypto";
-import { mkdir, rename, rm, writeFile } from "node:fs/promises";
+import { lstat, mkdir, rename, rm, writeFile } from "node:fs/promises";
 import { dirname } from "node:path";
 //#region lib/types/index.js
 /**
@@ -44,34 +44,54 @@ async function writeFileAtomic(filename, content, options) {
 		throw error;
 	}
 }
-/** Whether an exclusive create failed because the path already exists. */
-function isEEXIST(error) {
-	return error?.code === "EEXIST";
+/** Whether an exclusive create found an existing lock. */
+async function isLockContention(error, lockPath) {
+	const code = error?.code;
+	if (code === "EEXIST") return true;
+	if (code !== "EPERM") return false;
+	try {
+		await lstat(lockPath);
+		return true;
+	} catch {
+		return false;
+	}
 }
 /**
-* Writer-lock protocol constants. These are robustness invariants of the
-* cross-process write protocol, not deployment tunables: contention normally
-* resolves within the retry deadline, while expiry fails the contender without
-* guessing whether the existing lock still has an owner.
+* Retry cadence for a contended lock. These stay robustness invariants of the
+* cross-process write protocol rather than deployment tunables: they govern how
+* often a contender asks, which no caller has a reason to vary.
 */
 const LOCK_RETRY_INITIAL_MS = 20;
 const LOCK_RETRY_MAX_MS = 200;
-const LOCK_TIMEOUT_MS = 2e3;
+/**
+* How long a contender waits when the caller states no limit — sized for the
+* render-and-rename cycle every call site had when this package was written.
+* Expiry fails the contender rather than guessing whether the existing lock
+* still has an owner. How long is *worth* waiting is a property of the
+* operation the lock holder runs, which is why {@link FileLockOptions.waitMs}
+* exists; the value here is the floor for an operation that does file work
+* alone.
+*/
+const DEFAULT_LOCK_WAIT_MS = 2e3;
 /**
 * Hold the cross-process writer lock for `filename` around one operation. The
 * lock is a `wx`-created sibling (`<filename>.lock`); paired with the
 * rename-based commit of {@link writeFileAtomic}, readers stay lock-free and
-* only writers contend. Contention backs off exponentially and fails with a
-* timed-out error after the deadline. The contender never removes an existing
-* lock because file age cannot prove that its owner stopped; orphan recovery
-* is an operator action. The parent directory must exist.
+* only writers contend. `EEXIST` is contention directly; an `EPERM` is
+* contention only when a fresh `lstat` confirms the lock path exists, covering
+* Windows exclusive-create behavior without hiding an unrelated permission
+* failure. Contention backs off exponentially and fails with a timed-out error
+* after the deadline. The contender never removes an existing lock because
+* file age cannot prove that its owner stopped; orphan recovery is an operator
+* action. The parent directory must exist.
 * @param filename - the file whose writers this lock serializes.
 * @param operation - the read-render-commit cycle to run while holding the lock.
+* @param options - acquisition options; omitted waits {@link DEFAULT_LOCK_WAIT_MS}.
 * @returns the operation's result; the lock releases on both outcomes.
 */
-async function withFileLock(filename, operation) {
+async function withFileLock(filename, operation, options) {
 	const lockPath = `${filename}.lock`;
-	const deadline = Date.now() + LOCK_TIMEOUT_MS;
+	const deadline = Date.now() + (options?.waitMs ?? DEFAULT_LOCK_WAIT_MS);
 	let delay = LOCK_RETRY_INITIAL_MS;
 	for (;;) {
 		try {
@@ -81,7 +101,7 @@ async function withFileLock(filename, operation) {
 			});
 			break;
 		} catch (error) {
-			if (!isEEXIST(error)) throw error;
+			if (!await isLockContention(error, lockPath)) throw error;
 		}
 		if (Date.now() >= deadline) throw new Error(`atomic-write: timed out waiting for the writer lock at ${lockPath}`);
 		await new Promise((resolve) => setTimeout(resolve, delay));

package/dist/kernel/atomic-write/lib/types/index.d.ts

@@ -41,17 +41,33 @@ export interface WriteFileAtomicOptions {
  * @param options - permission bits for the replacement inode.
  */
 export declare function writeFileAtomic(filename: string, content: string, options: WriteFileAtomicOptions): Promise<void>;
+/** Options for one {@link withFileLock} acquisition. */
+export interface FileLockOptions {
+    /**
+     * Maximum time to wait for the lock, in milliseconds. State one when the
+     * holder's operation legitimately runs longer than file work — a credential
+     * mutation that refreshes a token performs a network round trip while
+     * holding the lock, and leaving the default in place would fail every other
+     * writer of the same file for the duration. Waiting is productive: a
+     * contender that acquires the lock afterwards re-reads the committed state.
+     */
+    waitMs?: number;
+}
 /**
  * Hold the cross-process writer lock for `filename` around one operation. The
  * lock is a `wx`-created sibling (`<filename>.lock`); paired with the
  * rename-based commit of {@link writeFileAtomic}, readers stay lock-free and
- * only writers contend. Contention backs off exponentially and fails with a
- * timed-out error after the deadline. The contender never removes an existing
- * lock because file age cannot prove that its owner stopped; orphan recovery
- * is an operator action. The parent directory must exist.
+ * only writers contend. `EEXIST` is contention directly; an `EPERM` is
+ * contention only when a fresh `lstat` confirms the lock path exists, covering
+ * Windows exclusive-create behavior without hiding an unrelated permission
+ * failure. Contention backs off exponentially and fails with a timed-out error
+ * after the deadline. The contender never removes an existing lock because
+ * file age cannot prove that its owner stopped; orphan recovery is an operator
+ * action. The parent directory must exist.
  * @param filename - the file whose writers this lock serializes.
  * @param operation - the read-render-commit cycle to run while holding the lock.
+ * @param options - acquisition options; omitted waits {@link DEFAULT_LOCK_WAIT_MS}.
  * @returns the operation's result; the lock releases on both outcomes.
  */
-export declare function withFileLock<T>(filename: string, operation: () => Promise<T>): Promise<T>;
+export declare function withFileLock<T>(filename: string, operation: () => Promise<T>, options?: FileLockOptions): Promise<T>;
 //# sourceMappingURL=index.d.ts.map

package/dist/kernel/atomic-write/lib/types/index.js

@@ -10,7 +10,7 @@
  * @module @nomix-ai/nomix-atomic-write
  */
 import { randomBytes } from 'node:crypto';
-import { mkdir, rename, rm, writeFile } from 'node:fs/promises';
+import { lstat, mkdir, rename, rm, writeFile } from 'node:fs/promises';
 import { dirname } from 'node:path';
 /**
  * Replace `filename` with `content` in one atomic step, creating parent
@@ -43,34 +43,58 @@ export async function writeFileAtomic(filename, content, options) {
         throw error;
     }
 }
-/** Whether an exclusive create failed because the path already exists. */
-function isEEXIST(error) {
-    return error?.code === 'EEXIST';
+/** Whether an exclusive create found an existing lock. */
+async function isLockContention(error, lockPath) {
+    const code = error?.code;
+    if (code === 'EEXIST')
+        return true;
+    if (code !== 'EPERM')
+        return false;
+    try {
+        await lstat(lockPath);
+        return true;
+    }
+    catch {
+        // Keep the original EPERM authoritative when lock existence is unproven.
+        return false;
+    }
 }
 /**
- * Writer-lock protocol constants. These are robustness invariants of the
- * cross-process write protocol, not deployment tunables: contention normally
- * resolves within the retry deadline, while expiry fails the contender without
- * guessing whether the existing lock still has an owner.
+ * Retry cadence for a contended lock. These stay robustness invariants of the
+ * cross-process write protocol rather than deployment tunables: they govern how
+ * often a contender asks, which no caller has a reason to vary.
  */
 const LOCK_RETRY_INITIAL_MS = 20;
 const LOCK_RETRY_MAX_MS = 200;
-const LOCK_TIMEOUT_MS = 2_000;
+/**
+ * How long a contender waits when the caller states no limit — sized for the
+ * render-and-rename cycle every call site had when this package was written.
+ * Expiry fails the contender rather than guessing whether the existing lock
+ * still has an owner. How long is *worth* waiting is a property of the
+ * operation the lock holder runs, which is why {@link FileLockOptions.waitMs}
+ * exists; the value here is the floor for an operation that does file work
+ * alone.
+ */
+const DEFAULT_LOCK_WAIT_MS = 2_000;
 /**
  * Hold the cross-process writer lock for `filename` around one operation. The
  * lock is a `wx`-created sibling (`<filename>.lock`); paired with the
  * rename-based commit of {@link writeFileAtomic}, readers stay lock-free and
- * only writers contend. Contention backs off exponentially and fails with a
- * timed-out error after the deadline. The contender never removes an existing
- * lock because file age cannot prove that its owner stopped; orphan recovery
- * is an operator action. The parent directory must exist.
+ * only writers contend. `EEXIST` is contention directly; an `EPERM` is
+ * contention only when a fresh `lstat` confirms the lock path exists, covering
+ * Windows exclusive-create behavior without hiding an unrelated permission
+ * failure. Contention backs off exponentially and fails with a timed-out error
+ * after the deadline. The contender never removes an existing lock because
+ * file age cannot prove that its owner stopped; orphan recovery is an operator
+ * action. The parent directory must exist.
  * @param filename - the file whose writers this lock serializes.
  * @param operation - the read-render-commit cycle to run while holding the lock.
+ * @param options - acquisition options; omitted waits {@link DEFAULT_LOCK_WAIT_MS}.
  * @returns the operation's result; the lock releases on both outcomes.
  */
-export async function withFileLock(filename, operation) {
+export async function withFileLock(filename, operation, options) {
     const lockPath = `${filename}.lock`;
-    const deadline = Date.now() + LOCK_TIMEOUT_MS;
+    const deadline = Date.now() + (options?.waitMs ?? DEFAULT_LOCK_WAIT_MS);
     let delay = LOCK_RETRY_INITIAL_MS;
     for (;;) {
         try {
@@ -78,7 +102,7 @@ export async function withFileLock(filename, operation) {
             break;
         }
         catch (error) {
-            if (!isEEXIST(error))
+            if (!await isLockContention(error, lockPath))
                 throw error;
         }
         if (Date.now() >= deadline) {

package/dist/kernel/atomic-write/lib/types/invariant.d.ts

@@ -2,7 +2,7 @@
  * Package-owned invariant companion for `@nomix-ai/nomix-atomic-write`.
  * @module @nomix-ai/nomix-atomic-write/invariant
  */
-import type { Context } from '@nomix-ai/cordis';
+import type { Context } from '../../../cordis/lib/index.js';
 /** Cordis companion plugin name. */
 export declare const name = "atomic-write-invariant";
 /** Service required before the companion can reserve package ownership. */

package/dist/kernel/atomic-write/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@nomix-ai/nomix-atomic-write",
   "description": "Zero-dependency atomic file replacement: exclusive-create random-suffix temp + rename carrying the caller-stated permissions (writeFileAtomic)",
-  "version": "0.2.4",
+  "version": "0.2.6",
   "publishConfig": {
     "access": "public"
   },

package/dist/kernel/attachment/lib/index.js

@@ -1,4 +1,5 @@
-import { Service } from "@nomix-ai/cordis";
+import { Service } from "../../cordis/lib/index.js";
+import { Buffer } from "node:buffer";
 //#region lib/types/error.js
 /** Runtime membership for structurally compatible errors crossing package boundaries. */
 const IMAGE_ADMISSION_ERROR_CODE_SET = new Set([
@@ -9,7 +10,8 @@ const IMAGE_ADMISSION_ERROR_CODE_SET = new Set([
 	"INVALID_IMAGE",
 	"IMAGE_TYPE_MISMATCH",
 	"IMAGE_TOO_LARGE",
-	"IMAGE_TOO_MANY_PIXELS"
+	"IMAGE_TOO_MANY_PIXELS",
+	"IMAGE_DIMENSION_TOO_LARGE"
 ]);
 /**
 * Stable failures suitable for host RPC error mapping.
@@ -53,6 +55,44 @@ function isImageAdmissionError(error) {
 function AttachmentId(value) {
 	return value;
 }
+/**
+* Brand a validated request-image transformation identifier.
+* @param value - attachment-provider-produced opaque identifier.
+* @returns the branded identifier.
+*/
+function ImageVariantId(value) {
+	return value;
+}
+//#endregion
+//#region lib/types/admission.js
+/** Wire-form admission of base64-encoded image uploads. @module @nomix-ai/nomix-attachment/admission */
+/** Decode one upload payload while rejecting non-canonical base64 forms. */
+function decodeBase64(data) {
+	const decoded = Buffer.from(data, "base64");
+	if (data.length === 0 || decoded.toString("base64") !== data) throw new AttachmentError("Image upload is not canonical base64.", "INVALID_IMAGE_BASE64");
+	return new Uint8Array(decoded);
+}
+/** Store input for one decoded upload. */
+function saveInput(image) {
+	return {
+		data: decodeBase64(image.data),
+		mediaType: image.mediaType,
+		...image.name === void 0 ? {} : { name: image.name }
+	};
+}
+/**
+* Admit one wire image batch: enforce canonical base64 on every member, then
+* delegate batch admission — count and aggregate-byte limits, media-type and
+* per-image validation, ordered commit — to {@link AttachmentStore.saveImages}.
+* The shared entry for every RPC endpoint accepting browser uploads.
+* @param attachments - the deployment attachment store owning batch policy.
+* @param images - base64-encoded uploads in caller order.
+* @returns durable references in the same order as `images`.
+* @throws AttachmentError on a non-canonical payload or a refused batch.
+*/
+async function admitEncodedImages(attachments, images) {
+	return attachments.saveImages(images.map(saveInput));
+}
 //#endregion
 //#region lib/types/index.js
 /** Durable attachment storage seam (`ctx.attachments`). @module @nomix-ai/nomix-attachment */
@@ -69,16 +109,35 @@ var AttachmentStore = class extends Service {
 	* @param inputs - encoded images in their owning message order.
 	* @returns durable references in the exact input order.
 	*/
-	async saveImages(inputs) {
+	validateImageBatch(inputs) {
 		const { maxImagesPerMessage, maxMessageImageBytes, mediaTypes } = this.imageLimits;
 		if (inputs.length > maxImagesPerMessage) throw new AttachmentError("Image batch exceeds the configured image-count limit.", "TOO_MANY_IMAGES");
 		if (inputs.reduce((sum, input) => sum + input.data.byteLength, 0) > maxMessageImageBytes) throw new AttachmentError("Image batch exceeds the configured aggregate image-byte limit.", "IMAGES_TOO_LARGE");
 		for (const input of inputs) if (!mediaTypes.includes(input.mediaType)) throw new AttachmentError(`Image type ${input.mediaType} is not accepted by this deployment.`, "UNSUPPORTED_IMAGE_TYPE");
+	}
+	/**
+	* Validate and durably commit one ordered image batch.
+	* @param inputs - encoded images in owning-message order.
+	* @returns durable normalized attachment references in the same order after every member succeeds.
+	*/
+	async saveImages(inputs) {
+		this.validateImageBatch(inputs);
 		for (const input of inputs) await this.validateImage(input);
 		const refs = [];
 		for (const input of inputs) refs.push(await this.saveImage(input));
 		return refs;
 	}
+	/**
+	* Generate or read one deterministic model-request version from the stored normalized image.
+	* @param ref - durable provider-independent normalized attachment reference.
+	* @param policy - exact route pixel and encoded-byte budget.
+	* @param signal - optional cancellation.
+	* @returns request bytes and the cache/upload identity covering every transform input.
+	*/
+	readImageRequest(ref, policy, signal) {
+		signal?.throwIfAborted();
+		return Promise.reject(new AttachmentError("The mounted attachment provider cannot derive model-request images.", "ATTACHMENT_PROJECTION_UNSUPPORTED"));
+	}
 };
 //#endregion
-export { AttachmentError, AttachmentId, AttachmentStore, AttachmentStore as default, isImageAdmissionError };
+export { AttachmentError, AttachmentId, AttachmentStore, AttachmentStore as default, ImageVariantId, admitEncodedImages, isImageAdmissionError };

package/dist/kernel/attachment/lib/types/admission.d.ts

@@ -0,0 +1,15 @@
+/** Wire-form admission of base64-encoded image uploads. @module @nomix-ai/nomix-attachment/admission */
+import type { AttachmentStore } from './index.ts';
+import type { EncodedImageAttachment, ImageAttachmentRef } from './types.ts';
+/**
+ * Admit one wire image batch: enforce canonical base64 on every member, then
+ * delegate batch admission — count and aggregate-byte limits, media-type and
+ * per-image validation, ordered commit — to {@link AttachmentStore.saveImages}.
+ * The shared entry for every RPC endpoint accepting browser uploads.
+ * @param attachments - the deployment attachment store owning batch policy.
+ * @param images - base64-encoded uploads in caller order.
+ * @returns durable references in the same order as `images`.
+ * @throws AttachmentError on a non-canonical payload or a refused batch.
+ */
+export declare function admitEncodedImages(attachments: AttachmentStore, images: readonly EncodedImageAttachment[]): Promise<readonly ImageAttachmentRef[]>;
+//# sourceMappingURL=admission.d.ts.map

package/dist/kernel/attachment/lib/types/admission.js

@@ -0,0 +1,33 @@
+/** Wire-form admission of base64-encoded image uploads. @module @nomix-ai/nomix-attachment/admission */
+import { Buffer } from 'node:buffer';
+import { AttachmentError } from "./error.js";
+/** Decode one upload payload while rejecting non-canonical base64 forms. */
+function decodeBase64(data) {
+    const decoded = Buffer.from(data, 'base64');
+    if (data.length === 0 || decoded.toString('base64') !== data) {
+        throw new AttachmentError('Image upload is not canonical base64.', 'INVALID_IMAGE_BASE64');
+    }
+    return new Uint8Array(decoded);
+}
+/** Store input for one decoded upload. */
+function saveInput(image) {
+    return {
+        data: decodeBase64(image.data),
+        mediaType: image.mediaType,
+        ...image.name === undefined ? {} : { name: image.name },
+    };
+}
+/**
+ * Admit one wire image batch: enforce canonical base64 on every member, then
+ * delegate batch admission — count and aggregate-byte limits, media-type and
+ * per-image validation, ordered commit — to {@link AttachmentStore.saveImages}.
+ * The shared entry for every RPC endpoint accepting browser uploads.
+ * @param attachments - the deployment attachment store owning batch policy.
+ * @param images - base64-encoded uploads in caller order.
+ * @returns durable references in the same order as `images`.
+ * @throws AttachmentError on a non-canonical payload or a refused batch.
+ */
+export async function admitEncodedImages(attachments, images) {
+    return attachments.saveImages(images.map(saveInput));
+}
+//# sourceMappingURL=admission.js.map

package/dist/kernel/attachment/lib/types/brand.d.ts

@@ -8,4 +8,12 @@ export type AttachmentId = Branded<'AttachmentId'>;
  * @returns the branded identifier.
  */
 export declare function AttachmentId(value: string): AttachmentId;
+/** Opaque deterministic identity for one request-image transformation. */
+export type ImageVariantId = Branded<'ImageVariantId'>;
+/**
+ * Brand a validated request-image transformation identifier.
+ * @param value - attachment-provider-produced opaque identifier.
+ * @returns the branded identifier.
+ */
+export declare function ImageVariantId(value: string): ImageVariantId;
 //# sourceMappingURL=brand.d.ts.map

package/dist/kernel/attachment/lib/types/brand.js

@@ -7,4 +7,12 @@
 export function AttachmentId(value) {
     return value;
 }
+/**
+ * Brand a validated request-image transformation identifier.
+ * @param value - attachment-provider-produced opaque identifier.
+ * @returns the branded identifier.
+ */
+export function ImageVariantId(value) {
+    return value;
+}
 //# sourceMappingURL=brand.js.map

package/dist/kernel/attachment/lib/types/error.d.ts

@@ -1,9 +1,9 @@
 /** Attachment failure class. @module @nomix-ai/nomix-attachment/error */
-declare const IMAGE_ADMISSION_ERROR_CODES: readonly ["TOO_MANY_IMAGES", "IMAGES_TOO_LARGE", "UNSUPPORTED_IMAGE_TYPE", "INVALID_IMAGE_BASE64", "INVALID_IMAGE", "IMAGE_TYPE_MISMATCH", "IMAGE_TOO_LARGE", "IMAGE_TOO_MANY_PIXELS"];
+declare const IMAGE_ADMISSION_ERROR_CODES: readonly ["TOO_MANY_IMAGES", "IMAGES_TOO_LARGE", "UNSUPPORTED_IMAGE_TYPE", "INVALID_IMAGE_BASE64", "INVALID_IMAGE", "IMAGE_TYPE_MISMATCH", "IMAGE_TOO_LARGE", "IMAGE_TOO_MANY_PIXELS", "IMAGE_DIMENSION_TOO_LARGE"];
 /** Caller-correctable attachment failure codes raised while admitting image input. */
 export type ImageAdmissionErrorCode = typeof IMAGE_ADMISSION_ERROR_CODES[number];
 /** Stable attachment failure codes used for protocol error routing. */
-export type AttachmentErrorCode = ImageAdmissionErrorCode | 'INVALID_ATTACHMENT_REF' | 'ATTACHMENT_CORRUPT' | 'ATTACHMENT_WRITE_FAILED' | 'ATTACHMENT_NOT_FOUND' | 'ATTACHMENT_READ_FAILED';
+export type AttachmentErrorCode = ImageAdmissionErrorCode | 'INVALID_ATTACHMENT_REF' | 'ATTACHMENT_CORRUPT' | 'ATTACHMENT_WRITE_FAILED' | 'ATTACHMENT_NOT_FOUND' | 'ATTACHMENT_READ_FAILED' | 'ATTACHMENT_PROJECTION_UNSUPPORTED';
 /**
  * Stable failures suitable for host RPC error mapping.
  *

package/dist/kernel/attachment/lib/types/error.js

@@ -8,6 +8,7 @@ const IMAGE_ADMISSION_ERROR_CODES = [
     'IMAGE_TYPE_MISMATCH',
     'IMAGE_TOO_LARGE',
     'IMAGE_TOO_MANY_PIXELS',
+    'IMAGE_DIMENSION_TOO_LARGE',
 ];
 /** Runtime membership for structurally compatible errors crossing package boundaries. */
 const IMAGE_ADMISSION_ERROR_CODE_SET = new Set(IMAGE_ADMISSION_ERROR_CODES);