@jini-ai/daemon 0.5.0 → 0.5.1

package/CHANGELOG.md

@@ -1,4 +1,9 @@
-## Unreleased
+## 0.5.1 — 2026-10-05
+
+- The `@jini-ai/db` peer range is `^0.2.0 || ^0.3.0` (daemon uses only db's kernel and store entries, which 0.3.0 leaves unchanged), so a host on db 0.3.0 installs without a peer conflict.
+- Internal `@jini-ai/*` runtime dependencies are caret ranges (`workspace:^`) instead of exact pins.
+
+## Unreleased (shipped in 0.5.0)
 
 ### Fixes
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jini-ai/daemon",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "description": "The stateful agent daemon runtime: run lifecycle, durable event-log port, the tool-execution boundary, agent executor, terminal sessions, and routines.",
   "license": "Apache-2.0",
   "repository": {
@@ -116,10 +116,10 @@
     "registry": "https://registry.npmjs.org"
   },
   "dependencies": {
-    "@jini-ai/core": "0.4.0",
-    "@jini-ai/agent-runtime": "0.4.0",
-    "@jini-ai/protocol": "0.4.0",
-    "@jini-ai/platform": "0.5.0"
+    "@jini-ai/agent-runtime": "^0.4.0",
+    "@jini-ai/core": "^0.4.1",
+    "@jini-ai/protocol": "^0.4.0",
+    "@jini-ai/platform": "^0.5.1"
   },
   "devDependencies": {
     "@vitest/coverage-v8": "^2.1.9",
@@ -132,13 +132,13 @@
     "@types/pg": "8.23.1",
     "express": "^4.21.0",
     "@types/express": "^4.17.21",
-    "@jini-ai/db": "0.2.0",
+    "@jini-ai/chat": "0.5.2",
     "@jini-ai/http-kit": "0.4.0",
-    "@jini-ai/chat": "0.5.0"
+    "@jini-ai/db": "0.3.0"
   },
   "peerDependencies": {
     "node-pty": "^1.1.0",
-    "@jini-ai/db": "^0.2.0",
+    "@jini-ai/db": "^0.2.0 || ^0.3.0",
     "kysely": "^0.29.6",
     "better-sqlite3": "^13.0.0",
     "@electric-sql/pglite": "0.5.8",

package/dist/artifacts/index.d.ts

@@ -1,14 +0,0 @@
-/**
- * @module artifacts
- *
- * The generic artifact-store kernel port, ported from OD's
- * `apps/daemon/src/artifacts/` (6 files). See `source-map.md` for full
- * per-file provenance and the design decisions behind each generalization.
- */
-export * from './manifest.js';
-export * from './store.js';
-export * from './publication-guard.js';
-export * from './runtime-compat.js';
-export * from './stub-guard.js';
-export * from './text-suppression.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/artifacts/index.js

@@ -1,14 +0,0 @@
-/**
- * @module artifacts
- *
- * The generic artifact-store kernel port, ported from OD's
- * `apps/daemon/src/artifacts/` (6 files). See `source-map.md` for full
- * per-file provenance and the design decisions behind each generalization.
- */
-export * from './manifest.js';
-export * from './store.js';
-export * from './publication-guard.js';
-export * from './runtime-compat.js';
-export * from './stub-guard.js';
-export * from './text-suppression.js';
-//# sourceMappingURL=index.js.map

package/dist/artifacts/manifest.d.ts

@@ -1,90 +0,0 @@
-/**
- * @module artifacts/manifest
- *
- * Generic artifact-manifest validation: bounded-length string checks, path-
- * traversal rejection on `entry`/`primary`/`supportingFiles`, a JSON-size
- * cap on `metadata`, and version/timestamp stamping. Ported from OD's
- * `apps/daemon/src/artifacts/manifest.ts`.
- *
- * De-branded: the origin's `kind`/`renderer` fields were validated against
- * hardcoded `ALLOWED_KINDS`/`ALLOWED_RENDERERS` sets that bake in OD's own
- * artifact taxonomy — including a literal `'design-system'` kind, OD's own
- * product concept, not a generic engine noun. Both sets are now a
- * caller-supplied {@link ArtifactManifestTaxonomy} instead of module
- * constants — a host (like an OD adapter) supplies its own kind/renderer/
- * export vocabulary; the validation *mechanism* (bounded strings, traversal
- * rejection, size caps, version stamping) is what this module owns. `status`
- * (`'streaming' | 'complete' | 'error'`) is kept as a fixed literal union —
- * that's a generic artifact-lifecycle concept, not a product taxonomy.
- */
-export type ArtifactStatus = 'streaming' | 'complete' | 'error';
-/**
- * A host's own artifact-kind/renderer/export vocabulary. The engine treats
- * every value as an opaque string it only bounds-checks and validates
- * membership against — it assigns no meaning to any particular kind name.
- */
-export interface ArtifactManifestTaxonomy {
-    readonly allowedKinds: ReadonlySet<string>;
-    readonly allowedRenderers: ReadonlySet<string>;
-    readonly allowedExports: ReadonlySet<string>;
-}
-/** A taxonomy that accepts nothing — forces a host to supply its own before any manifest can validate. */
-export declare const emptyArtifactManifestTaxonomy: ArtifactManifestTaxonomy;
-export interface ArtifactManifest {
-    readonly version: number;
-    readonly kind: string;
-    readonly title: string;
-    readonly entry: string;
-    readonly renderer: string;
-    readonly status: ArtifactStatus;
-    readonly exports: readonly string[];
-    readonly primary?: string | true;
-    readonly supportingFiles?: readonly string[];
-    readonly createdAt: string;
-    readonly updatedAt: string;
-    /** Generic "what produced or relates to this artifact" reference (OD: a skill id). Opaque to the engine. */
-    readonly sourceContextId?: string;
-    readonly metadata?: Readonly<Record<string, unknown>>;
-}
-type JsonRecord = Record<string, unknown>;
-type ValidationResult = {
-    ok: true;
-    value: ArtifactManifest | null;
-} | {
-    ok: false;
-    error: string;
-};
-export interface ValidateManifestOptions {
-    /** Keep an existing `updatedAt` instead of stamping the current time (used when re-parsing a persisted manifest). */
-    preserveUpdatedAt?: boolean;
-}
-/**
- * Validates a freeform manifest payload against `taxonomy`, returning a
- * sanitized, stamped {@link ArtifactManifest} on success. `manifest == null`
- * is a valid "no manifest supplied" outcome (`{ ok: true, value: null }`) —
- * callers that require a manifest check for `value === null` themselves
- * (see `store.ts`'s `resolveArtifactManifest`).
- */
-export declare function validateArtifactManifestInput(manifest: unknown, entry: unknown, taxonomy: ArtifactManifestTaxonomy, options?: ValidateManifestOptions): ValidationResult;
-/** Normalizes a validated manifest payload into the stamped, canonical {@link ArtifactManifest} shape. */
-export declare function sanitizeManifest(manifest: JsonRecord, entry: string, options?: ValidateManifestOptions): ArtifactManifest;
-/**
- * Re-validates a manifest read back from persistence (e.g. a sidecar file),
- * preserving its original `updatedAt`. Returns `null` on any validation
- * failure or version mismatch/parse error rather than throwing — a corrupt
- * or stale sidecar should degrade to "no manifest", not crash the reader.
- */
-export declare function parsePersistedManifest(raw: string, fallbackEntry: string, taxonomy: ArtifactManifestTaxonomy): ArtifactManifest | null;
-/**
- * Injectable seam for a host's own "what kind of artifact is this path"
- * heuristic (OD: extension-based HTML/deck/markdown/svg inference). The
- * engine has no default beyond "infer nothing" — see
- * {@link noopManifestInferrer} — a host wires in its own file-kind
- * classification (per the task brief: "keep OD's file-kind classification
- * as adapter").
- */
-export type ManifestInferrer = (entry: string) => Partial<ArtifactManifest> | null;
-/** Infers nothing — every create call must supply an explicit manifest. */
-export declare const noopManifestInferrer: ManifestInferrer;
-export {};
-//# sourceMappingURL=manifest.d.ts.map

package/dist/artifacts/manifest.js

@@ -1,229 +0,0 @@
-/**
- * @module artifacts/manifest
- *
- * Generic artifact-manifest validation: bounded-length string checks, path-
- * traversal rejection on `entry`/`primary`/`supportingFiles`, a JSON-size
- * cap on `metadata`, and version/timestamp stamping. Ported from OD's
- * `apps/daemon/src/artifacts/manifest.ts`.
- *
- * De-branded: the origin's `kind`/`renderer` fields were validated against
- * hardcoded `ALLOWED_KINDS`/`ALLOWED_RENDERERS` sets that bake in OD's own
- * artifact taxonomy — including a literal `'design-system'` kind, OD's own
- * product concept, not a generic engine noun. Both sets are now a
- * caller-supplied {@link ArtifactManifestTaxonomy} instead of module
- * constants — a host (like an OD adapter) supplies its own kind/renderer/
- * export vocabulary; the validation *mechanism* (bounded strings, traversal
- * rejection, size caps, version stamping) is what this module owns. `status`
- * (`'streaming' | 'complete' | 'error'`) is kept as a fixed literal union —
- * that's a generic artifact-lifecycle concept, not a product taxonomy.
- */
-const MANIFEST_VERSION = 1;
-const MAX_TITLE_LENGTH = 200;
-const MAX_SOURCE_CONTEXT_ID_LENGTH = 128;
-const MAX_SUPPORTING_FILE_LENGTH = 260;
-const MAX_SUPPORTING_FILES = 128;
-const MAX_METADATA_BYTES = 16 * 1024;
-const ALLOWED_STATUS = new Set(['streaming', 'complete', 'error']);
-/** A taxonomy that accepts nothing — forces a host to supply its own before any manifest can validate. */
-export const emptyArtifactManifestTaxonomy = {
-    allowedKinds: new Set(),
-    allowedRenderers: new Set(),
-    allowedExports: new Set(),
-};
-function isPlainObject(value) {
-    if (!value || typeof value !== 'object' || Array.isArray(value))
-        return false;
-    const proto = Object.getPrototypeOf(value);
-    return proto === Object.prototype || proto === null;
-}
-function validateBoundedString(value, field, maxLen, { allowEmpty = false } = {}) {
-    if (typeof value !== 'string')
-        return `${field} must be a string`;
-    if (!allowEmpty && value.length === 0)
-        return `${field} is required`;
-    if (value.length > maxLen)
-        return `${field} exceeds max length (${maxLen})`;
-    return null;
-}
-function validateSupportingPath(value) {
-    if (typeof value !== 'string')
-        return 'supportingFiles entries must be strings';
-    if (value.length === 0)
-        return 'supportingFiles entries cannot be empty';
-    if (value.length > MAX_SUPPORTING_FILE_LENGTH) {
-        return `supportingFiles entries exceed max length (${MAX_SUPPORTING_FILE_LENGTH})`;
-    }
-    if (/^[A-Za-z]:/.test(value) || value.startsWith('/')) {
-        return 'supportingFiles cannot contain absolute paths';
-    }
-    if (value.includes('\u0000'))
-        return 'supportingFiles cannot contain null bytes';
-    const normalized = value.replace(/\\/g, '/');
-    if (normalized.includes('..'))
-        return 'supportingFiles cannot contain traversal segments';
-    const parts = normalized.split('/').filter(Boolean);
-    if (parts.length === 0 || parts.some((p) => p === '.' || p === '..')) {
-        return 'supportingFiles cannot contain traversal segments';
-    }
-    return null;
-}
-/**
- * Validates a freeform manifest payload against `taxonomy`, returning a
- * sanitized, stamped {@link ArtifactManifest} on success. `manifest == null`
- * is a valid "no manifest supplied" outcome (`{ ok: true, value: null }`) —
- * callers that require a manifest check for `value === null` themselves
- * (see `store.ts`'s `resolveArtifactManifest`).
- */
-export function validateArtifactManifestInput(manifest, entry, taxonomy, options = {}) {
-    if (manifest == null)
-        return { ok: true, value: null };
-    if (!isPlainObject(manifest)) {
-        return { ok: false, error: 'artifactManifest must be an object' };
-    }
-    const kindErr = validateBoundedString(manifest.kind, 'artifactManifest.kind', 64);
-    if (kindErr)
-        return { ok: false, error: kindErr };
-    // Cast, not a runtime guard: validateBoundedString's first check is
-    // `typeof value !== 'string'`, which already returned above for any
-    // non-string `kind` — this only narrows the type for `taxonomy.allowedKinds.has`.
-    if (!taxonomy.allowedKinds.has(manifest.kind)) {
-        return { ok: false, error: 'artifactManifest.kind is not allowed' };
-    }
-    const rendererErr = validateBoundedString(manifest.renderer, 'artifactManifest.renderer', 64);
-    if (rendererErr)
-        return { ok: false, error: rendererErr };
-    // Same reasoning as `kind` above.
-    if (!taxonomy.allowedRenderers.has(manifest.renderer)) {
-        return { ok: false, error: 'artifactManifest.renderer is not allowed' };
-    }
-    if (!Array.isArray(manifest.exports) || manifest.exports.length === 0) {
-        return { ok: false, error: 'artifactManifest.exports must be a non-empty array' };
-    }
-    for (const exp of manifest.exports) {
-        if (typeof exp !== 'string') {
-            return { ok: false, error: 'artifactManifest.exports must contain strings' };
-        }
-        if (!taxonomy.allowedExports.has(exp)) {
-            return { ok: false, error: `artifactManifest.exports contains unsupported value: ${exp}` };
-        }
-    }
-    if (manifest.status !== undefined) {
-        if (typeof manifest.status !== 'string') {
-            return { ok: false, error: 'artifactManifest.status must be a string' };
-        }
-        if (!ALLOWED_STATUS.has(manifest.status)) {
-            return { ok: false, error: 'artifactManifest.status is not allowed' };
-        }
-    }
-    if (manifest.primary !== undefined) {
-        if (manifest.primary !== true) {
-            const primaryErr = validateSupportingPath(manifest.primary);
-            if (primaryErr)
-                return { ok: false, error: `artifactManifest.primary ${primaryErr}` };
-        }
-    }
-    if (manifest.supportingFiles !== undefined) {
-        if (!Array.isArray(manifest.supportingFiles)) {
-            return { ok: false, error: 'artifactManifest.supportingFiles must be an array' };
-        }
-        if (manifest.supportingFiles.length > MAX_SUPPORTING_FILES) {
-            return {
-                ok: false,
-                error: `artifactManifest.supportingFiles exceeds max items (${MAX_SUPPORTING_FILES})`,
-            };
-        }
-        for (const rel of manifest.supportingFiles) {
-            const relErr = validateSupportingPath(rel);
-            if (relErr)
-                return { ok: false, error: relErr };
-        }
-    }
-    if (manifest.title !== undefined) {
-        const titleErr = validateBoundedString(manifest.title, 'artifactManifest.title', MAX_TITLE_LENGTH, {
-            allowEmpty: false,
-        });
-        if (titleErr)
-            return { ok: false, error: titleErr };
-    }
-    if (manifest.sourceContextId !== undefined) {
-        const sourceErr = validateBoundedString(manifest.sourceContextId, 'artifactManifest.sourceContextId', MAX_SOURCE_CONTEXT_ID_LENGTH, { allowEmpty: true });
-        if (sourceErr)
-            return { ok: false, error: sourceErr };
-    }
-    if (manifest.metadata !== undefined) {
-        if (!isPlainObject(manifest.metadata)) {
-            return { ok: false, error: 'artifactManifest.metadata must be a plain object' };
-        }
-        // JSON.stringify always returns a string (never undefined) when called
-        // directly on a plain object — undefined-return only happens when the
-        // top-level argument itself is a function/symbol/undefined, which
-        // isPlainObject above already rejected.
-        const serialized = JSON.stringify(manifest.metadata);
-        if (Buffer.byteLength(serialized, 'utf8') > MAX_METADATA_BYTES) {
-            return {
-                ok: false,
-                error: `artifactManifest.metadata exceeds max size (${MAX_METADATA_BYTES} bytes)`,
-            };
-        }
-    }
-    const manifestEntry = typeof manifest.entry === 'string' && manifest.entry.trim() ? manifest.entry.trim() : entry;
-    const entryErr = validateSupportingPath(manifestEntry);
-    if (entryErr) {
-        return { ok: false, error: `artifactManifest.entry ${entryErr}` };
-    }
-    const safeEntry = manifestEntry.replace(/\\/g, '/');
-    return { ok: true, value: sanitizeManifest(manifest, safeEntry, options) };
-}
-/** Normalizes a validated manifest payload into the stamped, canonical {@link ArtifactManifest} shape. */
-export function sanitizeManifest(manifest, entry, options = {}) {
-    const now = new Date().toISOString();
-    const supportingFiles = Array.isArray(manifest.supportingFiles)
-        ? manifest.supportingFiles.map((x) => String(x).replace(/\\/g, '/'))
-        : undefined;
-    const primary = manifest.primary === true
-        ? true
-        : typeof manifest.primary === 'string'
-            ? manifest.primary.replace(/\\/g, '/')
-            : undefined;
-    return {
-        version: MANIFEST_VERSION,
-        kind: manifest.kind,
-        title: manifest.title || entry,
-        entry,
-        renderer: manifest.renderer,
-        status: typeof manifest.status === 'string' && ALLOWED_STATUS.has(manifest.status)
-            ? manifest.status
-            : 'complete',
-        exports: manifest.exports,
-        ...(primary !== undefined ? { primary } : {}),
-        ...(supportingFiles !== undefined ? { supportingFiles } : {}),
-        createdAt: typeof manifest.createdAt === 'string' ? manifest.createdAt : now,
-        updatedAt: options.preserveUpdatedAt && typeof manifest.updatedAt === 'string'
-            ? manifest.updatedAt
-            : now,
-        ...(manifest.sourceContextId !== undefined ? { sourceContextId: manifest.sourceContextId } : {}),
-        ...(manifest.metadata !== undefined ? { metadata: manifest.metadata } : {}),
-    };
-}
-/**
- * Re-validates a manifest read back from persistence (e.g. a sidecar file),
- * preserving its original `updatedAt`. Returns `null` on any validation
- * failure or version mismatch/parse error rather than throwing — a corrupt
- * or stale sidecar should degrade to "no manifest", not crash the reader.
- */
-export function parsePersistedManifest(raw, fallbackEntry, taxonomy) {
-    try {
-        const parsed = JSON.parse(raw);
-        if (!isPlainObject(parsed) || parsed.version !== MANIFEST_VERSION)
-            return null;
-        const entry = typeof parsed.entry === 'string' && parsed.entry ? parsed.entry : fallbackEntry;
-        const result = validateArtifactManifestInput(parsed, entry, taxonomy, { preserveUpdatedAt: true });
-        return result.ok ? result.value : null;
-    }
-    catch {
-        return null;
-    }
-}
-/** Infers nothing — every create call must supply an explicit manifest. */
-export const noopManifestInferrer = () => null;
-//# sourceMappingURL=manifest.js.map

package/dist/artifacts/publication-guard.d.ts

@@ -1,28 +0,0 @@
-export declare const ARTIFACT_PUBLICATION_BLOCKED_CODE: "ARTIFACT_PUBLICATION_BLOCKED";
-export interface PublicationGuardConfig {
-    /** Artifact kinds this guard scans. A kind not in this set is never blocked, whatever its content. */
-    readonly guardedKinds: ReadonlySet<string>;
-    /** Substrings that mark an artifact as containing an unresolved placeholder. Matching is case-sensitive. */
-    readonly blockedPlaceholders: readonly string[];
-}
-/** A guard that blocks nothing — no guarded kinds, no placeholder markers configured. */
-export declare const emptyPublicationGuardConfig: PublicationGuardConfig;
-export declare class ArtifactPublicationBlockedError extends Error {
-    readonly code: "ARTIFACT_PUBLICATION_BLOCKED";
-    readonly placeholders: readonly string[];
-    constructor(placeholders: readonly string[]);
-}
-export declare function isPublicationGuardedKind(kind: unknown, config: PublicationGuardConfig): boolean;
-/** Returns every configured placeholder marker found in `value`'s stringified content, in declaration order. */
-export declare function findBlockedPlaceholders(value: unknown, config: PublicationGuardConfig): string[];
-export declare function shouldBlockPublication(value: unknown, config: PublicationGuardConfig): boolean;
-export declare function buildArtifactPublicationBlockedMessage(placeholders: readonly string[]): string;
-/**
- * Throws {@link ArtifactPublicationBlockedError} when `value` (for a
- * `kind` in `config.guardedKinds`) contains any of `config.blockedPlaceholders`.
- * No-ops for a kind outside `config.guardedKinds` — a guard scoped to
- * user-facing rendered documents shouldn't reject content in other kinds
- * where the same substrings could be legitimate.
- */
-export declare function assertArtifactPublicationAllowed(kind: unknown, value: unknown, config: PublicationGuardConfig): void;
-//# sourceMappingURL=publication-guard.d.ts.map

package/dist/artifacts/publication-guard.js

@@ -1,77 +0,0 @@
-/**
- * @module artifacts/publication-guard
- *
- * A pre-publish content guard: blocks an artifact write when its body
- * contains a caller-declared "unresolved placeholder" marker, scoped to a
- * caller-declared set of guarded kinds. Ported from OD's
- * `apps/daemon/src/artifacts/publication-guard.ts`.
- *
- * De-branded: the origin hardcoded `UNRESOLVED_ARTIFACT_PLACEHOLDERS` — five
- * literal strings ("Name to confirm", "$X.XM", ...) lifted from one specific
- * bundled example template's pitch-deck fill-in-the-blank convention — and
- * `PUBLICATION_GUARDED_ARTIFACT_KINDS = {'html', 'deck'}`. Both are entirely
- * OD's own content, not a generic engine mechanism, so this module now takes
- * a caller-supplied {@link PublicationGuardConfig} (empty by default — a
- * guard that never blocks anything until a host configures it) instead of
- * baking in that one template's marker strings. The guard *mechanism*
- * (scan a guarded-kind body for any configured marker, throw before
- * publish) is what this module owns.
- */
-import { Buffer } from 'node:buffer';
-export const ARTIFACT_PUBLICATION_BLOCKED_CODE = 'ARTIFACT_PUBLICATION_BLOCKED';
-/** A guard that blocks nothing — no guarded kinds, no placeholder markers configured. */
-export const emptyPublicationGuardConfig = {
-    guardedKinds: new Set(),
-    blockedPlaceholders: [],
-};
-export class ArtifactPublicationBlockedError extends Error {
-    code = ARTIFACT_PUBLICATION_BLOCKED_CODE;
-    placeholders;
-    constructor(placeholders) {
-        super(buildArtifactPublicationBlockedMessage(placeholders));
-        this.name = 'ArtifactPublicationBlockedError';
-        this.placeholders = [...placeholders];
-    }
-}
-export function isPublicationGuardedKind(kind, config) {
-    return typeof kind === 'string' && config.guardedKinds.has(kind);
-}
-function stringifyArtifactContent(value) {
-    if (typeof value === 'string')
-        return value;
-    if (Buffer.isBuffer(value))
-        return value.toString('utf8');
-    if (value instanceof Uint8Array)
-        return Buffer.from(value).toString('utf8');
-    return '';
-}
-/** Returns every configured placeholder marker found in `value`'s stringified content, in declaration order. */
-export function findBlockedPlaceholders(value, config) {
-    const text = stringifyArtifactContent(value);
-    if (!text)
-        return [];
-    return config.blockedPlaceholders.filter((placeholder) => text.includes(placeholder));
-}
-export function shouldBlockPublication(value, config) {
-    return findBlockedPlaceholders(value, config).length > 0;
-}
-export function buildArtifactPublicationBlockedMessage(placeholders) {
-    const list = placeholders.length > 0 ? placeholders.join(', ') : 'unknown placeholders';
-    return `Artifact still contains unresolved placeholders: ${list}. Resolve them before publishing.`;
-}
-/**
- * Throws {@link ArtifactPublicationBlockedError} when `value` (for a
- * `kind` in `config.guardedKinds`) contains any of `config.blockedPlaceholders`.
- * No-ops for a kind outside `config.guardedKinds` — a guard scoped to
- * user-facing rendered documents shouldn't reject content in other kinds
- * where the same substrings could be legitimate.
- */
-export function assertArtifactPublicationAllowed(kind, value, config) {
-    if (!isPublicationGuardedKind(kind, config))
-        return;
-    const placeholders = findBlockedPlaceholders(value, config);
-    if (placeholders.length > 0) {
-        throw new ArtifactPublicationBlockedError(placeholders);
-    }
-}
-//# sourceMappingURL=publication-guard.js.map

package/dist/artifacts/runtime-compat.d.ts

@@ -1,37 +0,0 @@
-/**
- * @module artifacts/runtime-compat
- *
- * The runtime-compat injection seam: a hook that gets a chance to rewrite an
- * artifact's body before it's served, for CDN/library-loading quirks a host
- * knows about but the engine can't. Ported from OD's
- * `apps/daemon/src/artifacts/runtime-compat.ts`.
- *
- * De-branded: the origin, `normalizeArtifactRuntimeImports`, is entirely a
- * fix for one specific third-party CDN-bundle bug (the vanilla `dist/
- * motion.js` UMD script tag lacking React hooks, rewritten to `dist/
- * framer-motion.js`) that OD's own system prompt steers models toward
- * hitting. That rewrite rule is product/library-specific knowledge, not a
- * generic engine mechanism — per the task brief ("keep OD's specific logic
- * as adapter"), it is not ported. What *is* generic and kept is the
- * seam itself: a host may need to rewrite an artifact body for any number
- * of environment-specific reasons (a different CDN quirk, a different
- * runtime library entirely) before it reaches a renderer, so the engine
- * defines the hook type and a safe default (identity) rather than hardcode
- * any one library's fix.
- */
-/**
- * Rewrites an artifact body before it is served, keyed by the artifact's
- * file name (a host typically gates on file extension, as OD's origin did
- * with `.html`/`.htm`). Returns the body unchanged when no rewrite applies.
- */
-export type RuntimeCompatNormalizer = (name: string, body: unknown) => unknown;
-/** Applies no rewrite — returns `body` unchanged. Safe default until a host supplies its own normalizer(s). */
-export declare const noopRuntimeCompatNormalizer: RuntimeCompatNormalizer;
-/**
- * Composes several normalizers into one, applying each in order — the
- * output of one becomes the input to the next. Lets a host layer multiple
- * independent CDN/library fixes without each needing to know about the
- * others.
- */
-export declare function composeRuntimeCompatNormalizers(normalizers: readonly RuntimeCompatNormalizer[]): RuntimeCompatNormalizer;
-//# sourceMappingURL=runtime-compat.d.ts.map

package/dist/artifacts/runtime-compat.js

@@ -1,33 +0,0 @@
-/**
- * @module artifacts/runtime-compat
- *
- * The runtime-compat injection seam: a hook that gets a chance to rewrite an
- * artifact's body before it's served, for CDN/library-loading quirks a host
- * knows about but the engine can't. Ported from OD's
- * `apps/daemon/src/artifacts/runtime-compat.ts`.
- *
- * De-branded: the origin, `normalizeArtifactRuntimeImports`, is entirely a
- * fix for one specific third-party CDN-bundle bug (the vanilla `dist/
- * motion.js` UMD script tag lacking React hooks, rewritten to `dist/
- * framer-motion.js`) that OD's own system prompt steers models toward
- * hitting. That rewrite rule is product/library-specific knowledge, not a
- * generic engine mechanism — per the task brief ("keep OD's specific logic
- * as adapter"), it is not ported. What *is* generic and kept is the
- * seam itself: a host may need to rewrite an artifact body for any number
- * of environment-specific reasons (a different CDN quirk, a different
- * runtime library entirely) before it reaches a renderer, so the engine
- * defines the hook type and a safe default (identity) rather than hardcode
- * any one library's fix.
- */
-/** Applies no rewrite — returns `body` unchanged. Safe default until a host supplies its own normalizer(s). */
-export const noopRuntimeCompatNormalizer = (_name, body) => body;
-/**
- * Composes several normalizers into one, applying each in order — the
- * output of one becomes the input to the next. Lets a host layer multiple
- * independent CDN/library fixes without each needing to know about the
- * others.
- */
-export function composeRuntimeCompatNormalizers(normalizers) {
-    return (name, body) => normalizers.reduce((current, normalize) => normalize(name, current), body);
-}
-//# sourceMappingURL=runtime-compat.js.map

package/dist/artifacts/store.d.ts

@@ -1,85 +0,0 @@
-/**
- * @module artifacts/store
- *
- * `ArtifactStore` — the generic artifact-store kernel port. Ported from OD's
- * `apps/daemon/src/artifacts/create.ts` create/manifest-resolution flow;
- * "artifacts feel like a kernel-adjacent concept tied to runs producing
- * output" per this task's brief — homed in `@jini/daemon` alongside
- * `EventLog` (same async-port + in-memory-reference-implementation shape as
- * `event-log.ts`), not `@jini/core` (which owns pure registries/DI, not
- * stateful storage).
- *
- * De-branded: the origin's `createProjectArtifactFile` took OD's own
- * product-shaped workspace/file-tree writer (a function keyed on OD's own
- * workspace-root and workspace-id nouns) as its injected dependency, and a
- * companion `postCreateArtifactRequest` built a request body for OD's own
- * per-workspace HTTP file-upload route. Neither is a generic engine concern
- * (a workspace model and an HTTP route shape are product surfaces), so this
- * port defines `ArtifactStore.create/get/list` directly against an
- * in-memory reference map — the origin's writer/request-builder pair were
- * the composition points a real OD adapter would wire against this port
- * from, not something to port verbatim. OD's HTML-prototype file-kind
- * inference (`inferLegacyManifest`) stays adapter-owned — see
- * `manifest.ts`'s `ManifestInferrer` seam.
- */
-import { type ArtifactManifest, type ArtifactManifestTaxonomy, type ManifestInferrer } from './manifest.js';
-export declare class ArtifactManifestRequiredError extends Error {
-    readonly code: "ARTIFACT_MANIFEST_REQUIRED";
-    constructor(name: string);
-}
-export declare class ArtifactManifestInvalidError extends Error {
-    readonly code: "ARTIFACT_MANIFEST_INVALID";
-    constructor(message: string);
-}
-export interface CreateArtifactInput {
-    readonly name: string;
-    readonly content: string;
-    readonly encoding?: 'utf8' | 'base64';
-    /** Explicit manifest fields, or `undefined` to fall back to the store's {@link ManifestInferrer}. */
-    readonly artifactManifest?: unknown;
-}
-export interface ArtifactRecord {
-    readonly name: string;
-    readonly content: Buffer;
-    readonly manifest: ArtifactManifest;
-}
-/**
- * A replayable, ordered artifact-manifest resolver: given a create request,
- * either the caller-supplied manifest (validated against `taxonomy`) or the
- * result of `inferManifest(name)` (also validated) becomes the record's
- * manifest. Throws {@link ArtifactManifestRequiredError} when neither
- * source produces one, {@link ArtifactManifestInvalidError} when the
- * resolved manifest fails validation.
- */
-export declare function resolveArtifactManifest(input: CreateArtifactInput, taxonomy: ArtifactManifestTaxonomy, inferManifest: ManifestInferrer): ArtifactManifest;
-/**
- * A store of named artifacts with validated manifests. Kernel port —
- * `@jini/daemon` ships `createInMemoryArtifactStore` as the reference
- * implementation; a durable adapter (`@jini/sqlite`) can implement the same
- * interface against real persistence.
- */
-export interface ArtifactStore {
-    /**
-     * Creates or overwrites the artifact named `input.name`, resolving its
-     * manifest per {@link resolveArtifactManifest}.
-     * @throws {ArtifactManifestRequiredError} No manifest supplied and the inferrer produced none.
-     * @throws {ArtifactManifestInvalidError} The resolved manifest failed taxonomy validation.
-     */
-    create(input: CreateArtifactInput): Promise<ArtifactRecord>;
-    /** Returns the named artifact, or `null` if it doesn't exist. */
-    get(name: string): Promise<ArtifactRecord | null>;
-    /** Returns every stored artifact, most-recently-updated first. */
-    list(): Promise<ArtifactRecord[]>;
-}
-export interface InMemoryArtifactStoreOptions {
-    readonly taxonomy?: ArtifactManifestTaxonomy;
-    readonly inferManifest?: ManifestInferrer;
-}
-/**
- * Reference `ArtifactStore` implementation: an in-memory `Map` keyed by
- * artifact name. No durable persistence — matching this task's scope (a
- * real persistent adapter is a future storage task's concern, mirroring
- * `event-log.ts`'s own in-memory-only reference implementation).
- */
-export declare function createInMemoryArtifactStore(options?: InMemoryArtifactStoreOptions): ArtifactStore;
-//# sourceMappingURL=store.d.ts.map

package/dist/artifacts/store.js

@@ -1,92 +0,0 @@
-/**
- * @module artifacts/store
- *
- * `ArtifactStore` — the generic artifact-store kernel port. Ported from OD's
- * `apps/daemon/src/artifacts/create.ts` create/manifest-resolution flow;
- * "artifacts feel like a kernel-adjacent concept tied to runs producing
- * output" per this task's brief — homed in `@jini/daemon` alongside
- * `EventLog` (same async-port + in-memory-reference-implementation shape as
- * `event-log.ts`), not `@jini/core` (which owns pure registries/DI, not
- * stateful storage).
- *
- * De-branded: the origin's `createProjectArtifactFile` took OD's own
- * product-shaped workspace/file-tree writer (a function keyed on OD's own
- * workspace-root and workspace-id nouns) as its injected dependency, and a
- * companion `postCreateArtifactRequest` built a request body for OD's own
- * per-workspace HTTP file-upload route. Neither is a generic engine concern
- * (a workspace model and an HTTP route shape are product surfaces), so this
- * port defines `ArtifactStore.create/get/list` directly against an
- * in-memory reference map — the origin's writer/request-builder pair were
- * the composition points a real OD adapter would wire against this port
- * from, not something to port verbatim. OD's HTML-prototype file-kind
- * inference (`inferLegacyManifest`) stays adapter-owned — see
- * `manifest.ts`'s `ManifestInferrer` seam.
- */
-import { emptyArtifactManifestTaxonomy, noopManifestInferrer, validateArtifactManifestInput, } from './manifest.js';
-export class ArtifactManifestRequiredError extends Error {
-    code = 'ARTIFACT_MANIFEST_REQUIRED';
-    constructor(name) {
-        super(`artifactManifest is required for ${name}; no safe default manifest can be inferred`);
-        this.name = 'ArtifactManifestRequiredError';
-    }
-}
-export class ArtifactManifestInvalidError extends Error {
-    code = 'ARTIFACT_MANIFEST_INVALID';
-    constructor(message) {
-        super(`invalid artifactManifest: ${message}`);
-        this.name = 'ArtifactManifestInvalidError';
-    }
-}
-/**
- * A replayable, ordered artifact-manifest resolver: given a create request,
- * either the caller-supplied manifest (validated against `taxonomy`) or the
- * result of `inferManifest(name)` (also validated) becomes the record's
- * manifest. Throws {@link ArtifactManifestRequiredError} when neither
- * source produces one, {@link ArtifactManifestInvalidError} when the
- * resolved manifest fails validation.
- */
-export function resolveArtifactManifest(input, taxonomy, inferManifest) {
-    const manifest = input.artifactManifest !== undefined && input.artifactManifest !== null
-        ? input.artifactManifest
-        : inferManifest(input.name);
-    if (manifest) {
-        const validated = validateArtifactManifestInput(manifest, input.name, taxonomy);
-        if (!validated.ok) {
-            throw new ArtifactManifestInvalidError(validated.error);
-        }
-        // `manifest != null` above and `validateArtifactManifestInput` only
-        // returns `{ ok: true, value: null }` when its own `manifest` param is
-        // `== null` — so `validated.value` is non-null here.
-        return validated.value;
-    }
-    throw new ArtifactManifestRequiredError(input.name);
-}
-/**
- * Reference `ArtifactStore` implementation: an in-memory `Map` keyed by
- * artifact name. No durable persistence — matching this task's scope (a
- * real persistent adapter is a future storage task's concern, mirroring
- * `event-log.ts`'s own in-memory-only reference implementation).
- */
-export function createInMemoryArtifactStore(options = {}) {
-    const taxonomy = options.taxonomy ?? emptyArtifactManifestTaxonomy;
-    const inferManifest = options.inferManifest ?? noopManifestInferrer;
-    const records = new Map();
-    return {
-        async create(input) {
-            const manifest = resolveArtifactManifest(input, taxonomy, inferManifest);
-            const content = input.encoding === 'base64'
-                ? Buffer.from(input.content, 'base64')
-                : Buffer.from(input.content, 'utf8');
-            const record = { name: input.name, content, manifest };
-            records.set(input.name, record);
-            return record;
-        },
-        async get(name) {
-            return records.get(name) ?? null;
-        },
-        async list() {
-            return Array.from(records.values()).sort((a, b) => b.manifest.updatedAt.localeCompare(a.manifest.updatedAt));
-        },
-    };
-}
-//# sourceMappingURL=store.js.map

package/dist/artifacts/stub-guard.d.ts

@@ -1,73 +0,0 @@
-export type ArtifactStubGuardMode = 'reject' | 'warn' | 'off';
-export interface ArtifactStubGuardConfig {
-    readonly mode: ArtifactStubGuardMode;
-    readonly minRetainedRatio: number;
-    readonly minPriorBytes: number;
-    /** File-name extensions (including the leading dot) this guard scans for prior siblings, e.g. `['.html', '.htm']`. */
-    readonly siblingExtensions: readonly string[];
-}
-export interface PriorArtifactSibling {
-    readonly name: string;
-    readonly size: number;
-}
-export interface ArtifactStubGuardWarning {
-    readonly code: 'ARTIFACT_REGRESSION';
-    readonly message: string;
-    readonly identifier: string;
-    readonly newSize: number;
-    readonly priorSize: number;
-    readonly priorName: string;
-}
-export interface EvaluateArtifactStubGuardInput {
-    readonly scanDir: string;
-    readonly identifier: string;
-    readonly newSize: number;
-    readonly config: ArtifactStubGuardConfig;
-}
-export interface EvaluateArtifactStubGuardResult {
-    readonly outcome: 'pass' | 'warn' | 'reject';
-    readonly warning?: ArtifactStubGuardWarning;
-}
-export declare class ArtifactRegressionError extends Error {
-    readonly code = "ARTIFACT_REGRESSION";
-    readonly identifier: string;
-    readonly newSize: number;
-    readonly priorSize: number;
-    readonly priorName: string;
-    constructor(message: string, details: {
-        identifier: string;
-        newSize: number;
-        priorSize: number;
-        priorName: string;
-    });
-}
-export declare const DEFAULT_ARTIFACT_STUB_GUARD_CONFIG: ArtifactStubGuardConfig;
-/** Slugifies a free-form identifier into a filename-safe basename (lowercase, `[a-z0-9_-]`, max 60 chars). */
-export declare function slugifyArtifactIdentifier(value: string): string;
-/** Fallback basename used when a slugified identifier is empty (e.g. an all-non-ASCII identifier strips to nothing). */
-export declare const EMPTY_SLUG_FALLBACK_NAME = "artifact";
-/**
- * Two identifiers refer to the same artifact lineage when they're literally
- * equal, or one is the canonical slug form of the other (and that slug is
- * non-empty). Slug equality alone is not enough: a slugifier that truncates
- * at a fixed length would otherwise falsely bridge two distinct identifiers
- * that only diverge past that length — requiring one side to *be* the slug
- * form of the other avoids that while still bridging e.g. "Landing Page" and
- * "landing-page".
- */
-export declare function artifactIdentifiersMatch(a: string, b: string): boolean;
-/**
- * Finds prior siblings on disk that share an identifier with a newly-written
- * artifact, matching `<identifier>(-N)?.<ext>` for any of `config.siblingExtensions`.
- * The scan deliberately includes any file at the same path as the new write
- * — when a write overwrites an existing file with the same name, the file
- * currently on disk is the prior content (the overwrite happens after this
- * scan runs).
- */
-export declare function findPriorArtifactSiblings(scanDir: string, identifier: string, config: Pick<ArtifactStubGuardConfig, 'siblingExtensions'>): Promise<PriorArtifactSibling[]>;
-/** Reads guard config from `ARTIFACT_STUB_GUARD` / `ARTIFACT_STUB_GUARD_MIN_RATIO` / `ARTIFACT_STUB_GUARD_MIN_PRIOR_BYTES`, falling back to `defaults` for any unset/invalid value. */
-export declare function readArtifactStubGuardConfigFromEnv(env?: NodeJS.ProcessEnv, defaults?: ArtifactStubGuardConfig): ArtifactStubGuardConfig;
-/** Pure decision function: given the prior siblings on disk, decides whether the new body is a stub regression. Split from the disk scan so unit tests stay fast and can pre-fetch siblings. */
-export declare function classifyArtifactStubGuard(priors: readonly PriorArtifactSibling[], identifier: string, newSize: number, config: ArtifactStubGuardConfig): EvaluateArtifactStubGuardResult;
-export declare function evaluateArtifactStubGuard(input: EvaluateArtifactStubGuardInput): Promise<EvaluateArtifactStubGuardResult>;
-//# sourceMappingURL=stub-guard.d.ts.map

package/dist/artifacts/stub-guard.js

@@ -1,198 +0,0 @@
-import { readFile, readdir, stat } from 'node:fs/promises';
-import path from 'node:path';
-export class ArtifactRegressionError extends Error {
-    code = 'ARTIFACT_REGRESSION';
-    identifier;
-    newSize;
-    priorSize;
-    priorName;
-    constructor(message, details) {
-        super(message);
-        this.name = 'ArtifactRegressionError';
-        this.identifier = details.identifier;
-        this.newSize = details.newSize;
-        this.priorSize = details.priorSize;
-        this.priorName = details.priorName;
-    }
-}
-export const DEFAULT_ARTIFACT_STUB_GUARD_CONFIG = {
-    mode: 'warn',
-    minRetainedRatio: 0.2,
-    minPriorBytes: 4096,
-    siblingExtensions: ['.html', '.htm'],
-};
-function escapeRegExp(value) {
-    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
-/** Slugifies a free-form identifier into a filename-safe basename (lowercase, `[a-z0-9_-]`, max 60 chars). */
-export function slugifyArtifactIdentifier(value) {
-    return value
-        .toLowerCase()
-        .replace(/[^a-z0-9_-]+/g, '-')
-        .replace(/^-+|-+$/g, '')
-        .slice(0, 60);
-}
-/** Fallback basename used when a slugified identifier is empty (e.g. an all-non-ASCII identifier strips to nothing). */
-export const EMPTY_SLUG_FALLBACK_NAME = 'artifact';
-/**
- * Two identifiers refer to the same artifact lineage when they're literally
- * equal, or one is the canonical slug form of the other (and that slug is
- * non-empty). Slug equality alone is not enough: a slugifier that truncates
- * at a fixed length would otherwise falsely bridge two distinct identifiers
- * that only diverge past that length — requiring one side to *be* the slug
- * form of the other avoids that while still bridging e.g. "Landing Page" and
- * "landing-page".
- */
-export function artifactIdentifiersMatch(a, b) {
-    if (a === b)
-        return true;
-    const slugA = slugifyArtifactIdentifier(a);
-    if (slugA.length === 0)
-        return false;
-    const slugB = slugifyArtifactIdentifier(b);
-    if (slugA !== slugB)
-        return false;
-    return a === slugA || b === slugB;
-}
-async function readSidecarIdentifier(scanDir, entryName) {
-    try {
-        const raw = await readFile(path.join(scanDir, `${entryName}.artifact.json`), 'utf8');
-        const parsed = JSON.parse(raw);
-        const id = parsed?.metadata?.identifier;
-        return typeof id === 'string' && id.length > 0 ? id : null;
-    }
-    catch {
-        return null;
-    }
-}
-function extensionAlternation(extensions) {
-    return extensions.map((ext) => escapeRegExp(ext)).join('|');
-}
-function legacyCandidateIdentifiers(filename, extensionPattern, suffixPattern) {
-    const fullBasename = filename.replace(extensionPattern, '');
-    const stripped = filename.replace(suffixPattern, '');
-    const candidates = [];
-    if (fullBasename.length > 0)
-        candidates.push(fullBasename);
-    if (stripped.length > 0 && stripped !== fullBasename)
-        candidates.push(stripped);
-    return candidates;
-}
-/**
- * Finds prior siblings on disk that share an identifier with a newly-written
- * artifact, matching `<identifier>(-N)?.<ext>` for any of `config.siblingExtensions`.
- * The scan deliberately includes any file at the same path as the new write
- * — when a write overwrites an existing file with the same name, the file
- * currently on disk is the prior content (the overwrite happens after this
- * scan runs).
- */
-export async function findPriorArtifactSiblings(scanDir, identifier, config) {
-    if (identifier.length === 0)
-        return [];
-    const extAlternation = extensionAlternation(config.siblingExtensions);
-    if (!extAlternation)
-        return [];
-    const extensionPattern = new RegExp(`(?:${extAlternation})$`, 'i');
-    const suffixPattern = new RegExp(`(?:-\\d+)?(?:${extAlternation})$`, 'i');
-    const tokens = new Set();
-    tokens.add(identifier);
-    const slug = slugifyArtifactIdentifier(identifier);
-    if (slug.length > 0)
-        tokens.add(slug);
-    else
-        tokens.add(EMPTY_SLUG_FALLBACK_NAME);
-    const alternation = Array.from(tokens, escapeRegExp).join('|');
-    const pattern = new RegExp(`^(?:${alternation})(?:-\\d+)?(?:${extAlternation})$`, 'i');
-    let entries;
-    try {
-        entries = await readdir(scanDir, { withFileTypes: true });
-    }
-    catch {
-        return [];
-    }
-    const results = [];
-    for (const entry of entries) {
-        if (!entry.isFile())
-            continue;
-        if (!pattern.test(entry.name))
-            continue;
-        const sidecarIdentifier = await readSidecarIdentifier(scanDir, entry.name);
-        // `legacyCandidateIdentifiers` always returns at least one non-empty
-        // candidate here: `entry.name` already matched `pattern` above, which
-        // requires its basename to start with one of `tokens` (all non-empty),
-        // so an explicit `candidateIdentifiers.length === 0` guard would be
-        // dead code — an empty array's `.some()` below already `continue`s.
-        const candidateIdentifiers = sidecarIdentifier !== null
-            ? [sidecarIdentifier]
-            : legacyCandidateIdentifiers(entry.name, extensionPattern, suffixPattern);
-        if (!candidateIdentifiers.some((c) => artifactIdentifiersMatch(identifier, c)))
-            continue;
-        try {
-            const st = await stat(path.join(scanDir, entry.name));
-            results.push({ name: entry.name, size: st.size });
-        }
-        catch {
-            // Ignore unreadable entries — they don't influence the guard decision.
-        }
-    }
-    return results;
-}
-/** Reads guard config from `ARTIFACT_STUB_GUARD` / `ARTIFACT_STUB_GUARD_MIN_RATIO` / `ARTIFACT_STUB_GUARD_MIN_PRIOR_BYTES`, falling back to `defaults` for any unset/invalid value. */
-export function readArtifactStubGuardConfigFromEnv(env = process.env, defaults = DEFAULT_ARTIFACT_STUB_GUARD_CONFIG) {
-    const rawMode = (env.ARTIFACT_STUB_GUARD ?? '').toLowerCase();
-    const mode = rawMode === 'reject' || rawMode === 'warn' || rawMode === 'off' ? rawMode : defaults.mode;
-    const ratioRaw = Number(env.ARTIFACT_STUB_GUARD_MIN_RATIO);
-    // Accept (0, 1] so a caller can set 1 to reject any shrinkage. Values <=0 or >1 fall back to default.
-    const minRetainedRatio = Number.isFinite(ratioRaw) && ratioRaw > 0 && ratioRaw <= 1 ? ratioRaw : defaults.minRetainedRatio;
-    const minPriorBytesRaw = Number(env.ARTIFACT_STUB_GUARD_MIN_PRIOR_BYTES);
-    const minPriorBytes = Number.isInteger(minPriorBytesRaw) && minPriorBytesRaw > 0 ? minPriorBytesRaw : defaults.minPriorBytes;
-    return { mode, minRetainedRatio, minPriorBytes, siblingExtensions: defaults.siblingExtensions };
-}
-function buildWarning(identifier, newSize, prior) {
-    return {
-        code: 'ARTIFACT_REGRESSION',
-        message: `New artifact body for identifier "${identifier}" is ${newSize} bytes, ` +
-            `but the largest prior sibling "${prior.name}" is ${prior.size} bytes. ` +
-            'This pattern usually means the write emitted a placeholder instead of the full document. ' +
-            'Set the guard mode to "warn" to record the warning without rejecting, or "off" to disable the guard entirely.',
-        identifier,
-        newSize,
-        priorSize: prior.size,
-        priorName: prior.name,
-    };
-}
-/** Pure decision function: given the prior siblings on disk, decides whether the new body is a stub regression. Split from the disk scan so unit tests stay fast and can pre-fetch siblings. */
-export function classifyArtifactStubGuard(priors, identifier, newSize, config) {
-    if (config.mode === 'off')
-        return { outcome: 'pass' };
-    if (identifier.length === 0)
-        return { outcome: 'pass' };
-    if (priors.length === 0)
-        return { outcome: 'pass' };
-    let largestSoFar = null;
-    for (const prior of priors) {
-        if (largestSoFar === null || prior.size > largestSoFar.size)
-            largestSoFar = prior;
-    }
-    // Non-null assertion, not a runtime guard: `priors.length === 0` already
-    // returned above, so this loop always runs at least once, and its first
-    // iteration always satisfies `largestSoFar === null` — it's always
-    // assigned by the time the loop finishes.
-    const largest = largestSoFar;
-    if (largest.size < config.minPriorBytes)
-        return { outcome: 'pass' };
-    const threshold = largest.size * config.minRetainedRatio;
-    if (newSize >= threshold)
-        return { outcome: 'pass' };
-    const warning = buildWarning(identifier, newSize, largest);
-    return { outcome: config.mode === 'reject' ? 'reject' : 'warn', warning };
-}
-export async function evaluateArtifactStubGuard(input) {
-    if (input.config.mode === 'off')
-        return { outcome: 'pass' };
-    if (input.identifier.length === 0)
-        return { outcome: 'pass' };
-    const priors = await findPriorArtifactSiblings(input.scanDir, input.identifier, input.config);
-    return classifyArtifactStubGuard(priors, input.identifier, input.newSize, input.config);
-}
-//# sourceMappingURL=stub-guard.js.map

package/dist/artifacts/text-suppression.d.ts

@@ -1,68 +0,0 @@
-/**
- * @module artifacts/text-suppression
- *
- * A streaming-text state machine that suppresses a tagged block (matched by
- * caller-supplied open/close patterns) from user-visible output while it's
- * still arriving — used to hide an artifact's raw markup from chat prose
- * while it streams in, without buffering the whole response first. Ported
- * from OD's `apps/daemon/src/artifacts/text-suppression.ts`.
- *
- * The core (`createTaggedTextSuppressor`) was already fully generic in the
- * origin — it takes its open/close regexes and open/close prefix-match
- * predicates as parameters, no product coupling. What needed de-branding
- * were the origin's two pre-built instances: `createDsmlArtifactTextSuppressor`
- * hardcoded OD's own "DSML" markup-language tag name family
- * (`<|DSML artifact>`/`<artifact>`) as its open/close patterns.
- * `createXmlTagTextSuppressor` below replaces it — a generic factory taking
- * the caller's own tag-name list instead of a hardcoded vocabulary. The
- * `tool_call`/`edit` pairing the origin's other instance
- * (`createToolCallTextSuppressor`) suppressed is a generic agent-protocol
- * convention, not OD-branded, and is kept as a named default instance.
- */
-export type StreamTextEvent = {
-    readonly type: 'text_delta';
-    readonly delta: string;
-};
-export type StreamEventSink = (event: StreamTextEvent) => void;
-export interface ArtifactTextSuppressor {
-    strip(text: string): string;
-    flush(): string;
-    isSuppressing(): boolean;
-    hasPendingCandidate(): boolean;
-    stats(): ArtifactTextSuppressorStats;
-}
-export interface ArtifactTextSuppressorStats {
-    readonly suppressedChars: number;
-    readonly suppressedChunks: number;
-    readonly openedBlocks: number;
-    readonly closedBlocks: number;
-    readonly pendingCandidateChars: number;
-    readonly suppressing: boolean;
-}
-/**
- * Builds a suppressor for a tagged block delimited by `openRe`/`closeRe`.
- * `isPossibleOpen`/`isPossibleClose` decide whether a trailing `<...`
- * fragment (with no closing `>` yet) *could* still become a match once more
- * text arrives — this is what lets the suppressor hold back a
- * not-yet-decidable tail across streaming chunk boundaries instead of
- * either emitting a tag fragment early or hanging indefinitely on a `<` that
- * turns out to be unrelated text.
- */
-export declare function createTaggedTextSuppressor(args: {
-    openRe: RegExp;
-    closeRe: RegExp;
-    isPossibleOpen: (text: string) => boolean;
-    isPossibleClose: (text: string) => boolean;
-}): ArtifactTextSuppressor;
-/** Feeds `text` through `suppressor` and emits a `text_delta` on `onEvent` only when something survives. Returns whether an event was emitted. */
-export declare function emitWithTextSuppressor(suppressor: ArtifactTextSuppressor, onEvent: StreamEventSink, text: string): boolean;
-/**
- * Builds a suppressor for an XML-like `<tagName ...>...</tagName>` block (or
- * a bracket-pipe variant `<|tagName ...>...<|/tagName|>`), matched
- * case-insensitively against any of `tagNames`. Replaces the origin's
- * hardcoded "DSML" tag-name family with a caller-supplied vocabulary.
- */
-export declare function createXmlTagTextSuppressor(tagNames: readonly string[]): ArtifactTextSuppressor;
-/** Suppresses a `<tool_call>...</tool_call>` or `<edit>...</edit>` block — a generic agent-protocol convention, not product-branded. */
-export declare function createToolCallTextSuppressor(): ArtifactTextSuppressor;
-//# sourceMappingURL=text-suppression.d.ts.map

package/dist/artifacts/text-suppression.js

@@ -1,184 +0,0 @@
-/**
- * @module artifacts/text-suppression
- *
- * A streaming-text state machine that suppresses a tagged block (matched by
- * caller-supplied open/close patterns) from user-visible output while it's
- * still arriving — used to hide an artifact's raw markup from chat prose
- * while it streams in, without buffering the whole response first. Ported
- * from OD's `apps/daemon/src/artifacts/text-suppression.ts`.
- *
- * The core (`createTaggedTextSuppressor`) was already fully generic in the
- * origin — it takes its open/close regexes and open/close prefix-match
- * predicates as parameters, no product coupling. What needed de-branding
- * were the origin's two pre-built instances: `createDsmlArtifactTextSuppressor`
- * hardcoded OD's own "DSML" markup-language tag name family
- * (`<|DSML artifact>`/`<artifact>`) as its open/close patterns.
- * `createXmlTagTextSuppressor` below replaces it — a generic factory taking
- * the caller's own tag-name list instead of a hardcoded vocabulary. The
- * `tool_call`/`edit` pairing the origin's other instance
- * (`createToolCallTextSuppressor`) suppressed is a generic agent-protocol
- * convention, not OD-branded, and is kept as a named default instance.
- */
-const MAX_CANDIDATE_LENGTH = 512;
-/**
- * Builds a suppressor for a tagged block delimited by `openRe`/`closeRe`.
- * `isPossibleOpen`/`isPossibleClose` decide whether a trailing `<...`
- * fragment (with no closing `>` yet) *could* still become a match once more
- * text arrives — this is what lets the suppressor hold back a
- * not-yet-decidable tail across streaming chunk boundaries instead of
- * either emitting a tag fragment early or hanging indefinitely on a `<` that
- * turns out to be unrelated text.
- */
-export function createTaggedTextSuppressor(args) {
-    let suppressing = false;
-    let candidate = '';
-    let suppressedChars = 0;
-    let suppressedChunks = 0;
-    let openedBlocks = 0;
-    let closedBlocks = 0;
-    function noteSuppressed(text) {
-        if (text.length <= 0)
-            return;
-        suppressedChars += text.length;
-        suppressedChunks += 1;
-    }
-    function strip(text) {
-        const current = `${candidate}${text}`;
-        candidate = '';
-        if (suppressing) {
-            const close = args.closeRe.exec(current);
-            if (!close || close.index === undefined) {
-                const closeCandidateStart = possibleTagStart(current, args.isPossibleClose);
-                if (closeCandidateStart !== -1) {
-                    candidate = current.slice(closeCandidateStart);
-                    noteSuppressed(current.slice(0, closeCandidateStart));
-                }
-                else {
-                    noteSuppressed(current);
-                }
-                return '';
-            }
-            suppressing = false;
-            const end = close.index + close[0].length;
-            closedBlocks += 1;
-            noteSuppressed(current.slice(0, end));
-            return strip(current.slice(end));
-        }
-        const open = args.openRe.exec(current);
-        if (open && open.index !== undefined) {
-            suppressing = true;
-            openedBlocks += 1;
-            const prefix = current.slice(0, open.index);
-            const tail = current.slice(open.index + open[0].length);
-            noteSuppressed(open[0]);
-            return `${prefix}${strip(tail)}`;
-        }
-        const candidateStart = possibleTagStart(current, args.isPossibleOpen);
-        if (candidateStart === -1)
-            return current;
-        candidate = current.slice(candidateStart);
-        return current.slice(0, candidateStart);
-    }
-    function flush() {
-        const text = candidate;
-        candidate = '';
-        return suppressing ? '' : text;
-    }
-    function isSuppressing() {
-        return suppressing;
-    }
-    function hasPendingCandidate() {
-        return candidate.length > 0;
-    }
-    function stats() {
-        return {
-            suppressedChars,
-            suppressedChunks,
-            openedBlocks,
-            closedBlocks,
-            pendingCandidateChars: candidate.length,
-            suppressing,
-        };
-    }
-    return { strip, flush, isSuppressing, hasPendingCandidate, stats };
-}
-/** Feeds `text` through `suppressor` and emits a `text_delta` on `onEvent` only when something survives. Returns whether an event was emitted. */
-export function emitWithTextSuppressor(suppressor, onEvent, text) {
-    const delta = suppressor.strip(text);
-    if (!delta)
-        return false;
-    onEvent({ type: 'text_delta', delta });
-    return true;
-}
-function possibleTagStart(text, predicate) {
-    const min = Math.max(0, text.length - MAX_CANDIDATE_LENGTH);
-    let index = text.lastIndexOf('<');
-    while (index >= min) {
-        const tail = text.slice(index);
-        if (predicate(tail))
-            return index;
-        if (index === 0)
-            break;
-        index = text.lastIndexOf('<', index - 1);
-    }
-    return -1;
-}
-// `text` is always a `possibleTagStart` tail slice starting at a `<`
-// position (its only caller) — no `!text.startsWith('<')` re-check needed.
-function compactTagCandidate(text, stripChars) {
-    if (text.includes('>'))
-        return null;
-    return text.toLowerCase().replace(stripChars, '');
-}
-/**
- * Builds a suppressor for an XML-like `<tagName ...>...</tagName>` block (or
- * a bracket-pipe variant `<|tagName ...>...<|/tagName|>`), matched
- * case-insensitively against any of `tagNames`. Replaces the origin's
- * hardcoded "DSML" tag-name family with a caller-supplied vocabulary.
- */
-export function createXmlTagTextSuppressor(tagNames) {
-    const canonicals = tagNames.map((t) => t.toLowerCase());
-    const namesPattern = canonicals.map((t) => t.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')).join('|');
-    const openRe = new RegExp(`(?:<\\s*\\|?\\s*(?:${namesPattern})\\b[^>]*>)`, 'i');
-    const closeRe = new RegExp(`(?:<\\/(?:${namesPattern})>|<\\s*\\|?\\s*\\/\\s*(?:${namesPattern})\\s*\\|?\\s*>)`, 'i');
-    function isPossibleOpen(text) {
-        const compact = compactTagCandidate(text, /[<|,\s]/g);
-        if (compact === null)
-            return false;
-        return compact.length === 0 || canonicals.some((c) => c.startsWith(compact) || compact.startsWith(c));
-    }
-    function isPossibleClose(text) {
-        const compact = compactTagCandidate(text, /[<|/\s]/g);
-        if (compact === null)
-            return false;
-        return compact.length === 0 || canonicals.some((c) => c.startsWith(compact) || compact.startsWith(c));
-    }
-    return createTaggedTextSuppressor({ openRe, closeRe, isPossibleOpen, isPossibleClose });
-}
-const TOOL_CALL_OPEN_RE = /(?:<\s*tool_call\b[^>]*>|<\s*edit\s*>)/i;
-const TOOL_CALL_CLOSE_RE = /(?:<\/\s*tool_call\s*>|<\/\s*edit\s*>)/i;
-const TOOL_CALL_CANONICALS = ['toolcall', 'edit'];
-// Same reasoning as compactTagCandidate above: `text` always starts with
-// `<` here (a `possibleTagStart` tail slice) — no re-check needed.
-function isPossibleToolCallOpen(text) {
-    if (text.includes('>'))
-        return false;
-    const compact = text.toLowerCase().replace(/[<|,\s_-]/g, '');
-    return compact.length === 0 || TOOL_CALL_CANONICALS.some((c) => c.startsWith(compact) || compact.startsWith(c));
-}
-function isPossibleToolCallClose(text) {
-    if (text.includes('>'))
-        return false;
-    const compact = text.toLowerCase().replace(/[<|/\s_-]/g, '');
-    return compact.length === 0 || TOOL_CALL_CANONICALS.some((c) => c.startsWith(compact) || compact.startsWith(c));
-}
-/** Suppresses a `<tool_call>...</tool_call>` or `<edit>...</edit>` block — a generic agent-protocol convention, not product-branded. */
-export function createToolCallTextSuppressor() {
-    return createTaggedTextSuppressor({
-        openRe: TOOL_CALL_OPEN_RE,
-        closeRe: TOOL_CALL_CLOSE_RE,
-        isPossibleOpen: isPossibleToolCallOpen,
-        isPossibleClose: isPossibleToolCallClose,
-    });
-}
-//# sourceMappingURL=text-suppression.js.map