@nowcrew/daemon 0.6.88-beta.7 → 0.6.88-beta.9

package/dist/project-skills/projection-state-transaction.js

@@ -1,322 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { chmod, link, lstat, mkdir, readlink, rename, symlink } from "node:fs/promises";
-import { join } from "node:path";
-import { appliedProjectSkillManifestPath, projectSkillManifestStoreInternals as store, } from "./projection-state-store.js";
-const manifestsMatch = (left, right) => JSON.stringify(left) === JSON.stringify(right);
-export const projectSkillManifestUpdateRecord = (update) => Object.freeze({
-    managedBy: "nowcrew-project-skills-v2-update",
-    version: 1,
-    operationId: update.operationId,
-    previous: update.previous,
-    next: update.next,
-});
-export const parseProjectSkillManifestUpdateRecord = (candidate) => {
-    if (candidate === null || typeof candidate !== "object")
-        return store.pathUnmanaged();
-    const record = candidate;
-    if (record.managedBy !== "nowcrew-project-skills-v2-update"
-        || record.version !== 1
-        || typeof record.operationId !== "string"
-        || !store.ARTIFACT_ID.test(record.operationId)
-        || !("previous" in record)
-        || !("next" in record)
-        || Object.keys(record).sort().join(",") !== "managedBy,next,operationId,previous,version") {
-        return store.pathUnmanaged();
-    }
-    const previous = record.previous === null
-        ? null
-        : store.parseAppliedProjectSkillManifest(record.previous);
-    const next = record.next === null ? null : store.parseAppliedProjectSkillManifest(record.next);
-    return Object.freeze({
-        managedBy: "nowcrew-project-skills-v2-update",
-        version: 1,
-        operationId: record.operationId,
-        previous,
-        next,
-    });
-};
-export const preparedProjectSkillManifestUpdateFromRecord = (agentRoot, candidate) => {
-    const record = parseProjectSkillManifestUpdateRecord(candidate);
-    return Object.freeze({
-        agentRoot,
-        operationId: record.operationId,
-        previous: record.previous,
-        next: record.next,
-    });
-};
-const stateContext = async (agentRoot, options, settle) => {
-    const syncDirectory = store.projectionDirectorySync(options);
-    await store.realOwnedDirectory(agentRoot, false);
-    const stateDirectory = join(agentRoot, ".crew");
-    if (!await store.realOwnedDirectory(stateDirectory, true)) {
-        try {
-            await mkdir(stateDirectory, { mode: 0o700 });
-        }
-        catch (error) {
-            if (!store.isExisting(error))
-                return store.pathUnmanaged();
-        }
-        await store.realOwnedDirectory(stateDirectory, false);
-    }
-    await chmod(stateDirectory, 0o700).catch(() => store.pathUnmanaged());
-    const manifestPath = appliedProjectSkillManifestPath(agentRoot);
-    if (settle) {
-        await store.settleDiscardResidues(stateDirectory, syncDirectory);
-        await store.settlePreparingResidues(stateDirectory, syncDirectory);
-        await store.settleAnyExistingOperation(manifestPath, stateDirectory, syncDirectory);
-    }
-    return Object.freeze({ manifestPath, stateDirectory, syncDirectory });
-};
-const operationPath = (stateDirectory, operationId) => {
-    if (!store.ARTIFACT_ID.test(operationId))
-        return store.pathUnmanaged();
-    return join(stateDirectory, `${store.OPERATION_PREFIX}${operationId}${store.OPERATION_SUFFIX}`);
-};
-const loadBoundUpdate = async (update, options) => {
-    const context = await stateContext(update.agentRoot, options, false);
-    const operation = await store.loadOperation(operationPath(context.stateDirectory, update.operationId));
-    if (operation.intent.nonce !== update.operationId || operation.stage === null)
-        return store.pathUnmanaged();
-    const next = store.isAbsenceMarkerRaw(operation.intent.stage.content)
-        ? null
-        : store.parseManifestRaw(operation.intent.stage.content);
-    const previous = operation.intent.previous === null
-        ? null
-        : store.parseManifestRaw(operation.intent.previous.content);
-    if (!manifestsMatch(next, update.next) || !manifestsMatch(previous, update.previous)) {
-        return store.pathUnmanaged();
-    }
-    return Object.freeze({ ...context, operation });
-};
-const completedWithoutOperation = async (update, expected, options) => {
-    const context = await stateContext(update.agentRoot, options, false);
-    const path = operationPath(context.stateDirectory, update.operationId);
-    try {
-        await lstat(path);
-        return false;
-    }
-    catch (error) {
-        if (error.code !== "ENOENT")
-            return store.pathUnmanaged();
-    }
-    await store.settleDiscardResidues(context.stateDirectory, context.syncDirectory);
-    const current = await store.readStableFile(context.manifestPath, store.MAX_MANIFEST_BYTES);
-    const manifest = current === null ? null : store.parseManifestRaw(current.raw);
-    if (!manifestsMatch(manifest, expected))
-        return store.pathUnmanaged();
-    return true;
-};
-const restoreUnknownClaimNoClobber = async (claimedPath, manifestPath, syncDirectory, stateDirectory, afterSlotChecked) => {
-    const claimedIdentity = await lstat(claimedPath, { bigint: true }).catch(() => store.pathUnmanaged());
-    if (claimedIdentity.isFile()) {
-        try {
-            await link(claimedPath, manifestPath);
-            await syncDirectory(stateDirectory);
-        }
-        catch {
-            return store.pathUnmanaged();
-        }
-        const restored = await lstat(manifestPath, { bigint: true }).catch(() => store.pathUnmanaged());
-        if (restored.dev !== claimedIdentity.dev || restored.ino !== claimedIdentity.ino) {
-            return store.pathUnmanaged();
-        }
-        return store.pathUnmanaged();
-    }
-    try {
-        await lstat(manifestPath);
-        return store.pathUnmanaged();
-    }
-    catch (error) {
-        if (error.code !== "ENOENT")
-            return store.pathUnmanaged();
-    }
-    await afterSlotChecked?.();
-    if (!claimedIdentity.isSymbolicLink())
-        return store.pathUnmanaged();
-    const target = await readlink(claimedPath).catch(() => store.pathUnmanaged());
-    const beforeRestore = await lstat(claimedPath, { bigint: true }).catch(() => store.pathUnmanaged());
-    if (!beforeRestore.isSymbolicLink()
-        || beforeRestore.dev !== claimedIdentity.dev
-        || beforeRestore.ino !== claimedIdentity.ino) {
-        return store.pathUnmanaged();
-    }
-    try {
-        await symlink(target, manifestPath);
-        await syncDirectory(stateDirectory);
-    }
-    catch {
-        return store.pathUnmanaged();
-    }
-    const restored = await lstat(manifestPath, { bigint: true }).catch(() => store.pathUnmanaged());
-    if (!restored.isSymbolicLink()
-        || await readlink(manifestPath).catch(() => store.pathUnmanaged()) !== target) {
-        return store.pathUnmanaged();
-    }
-    return store.pathUnmanaged();
-};
-const claimPublicManifest = async (context, destinationBasename, expected, beforeClaim, afterClaim, afterRestoreSlotChecked) => {
-    const claimedPath = join(context.operation.path, destinationBasename);
-    await beforeClaim?.();
-    try {
-        await rename(context.manifestPath, claimedPath);
-        await context.syncDirectory(context.operation.path);
-        await context.syncDirectory(context.stateDirectory);
-    }
-    catch {
-        return store.pathUnmanaged();
-    }
-    await afterClaim?.(claimedPath);
-    const claimed = await store.readStableFile(claimedPath, store.MAX_MANIFEST_BYTES).catch(() => restoreUnknownClaimNoClobber(claimedPath, context.manifestPath, context.syncDirectory, context.stateDirectory, afterRestoreSlotChecked === undefined ? undefined : () => afterRestoreSlotChecked(claimedPath)));
-    if (claimed === null || !store.snapshotMatchesBinding(claimed, expected, true)) {
-        return restoreUnknownClaimNoClobber(claimedPath, context.manifestPath, context.syncDirectory, context.stateDirectory, afterRestoreSlotChecked === undefined ? undefined : () => afterRestoreSlotChecked(claimedPath));
-    }
-};
-const prepareManifestTransition = async (agentRoot, next, options = {}) => {
-    const context = await stateContext(agentRoot, options, true);
-    const current = await store.readStableFile(context.manifestPath, store.MAX_MANIFEST_BYTES);
-    const previous = current === null ? null : store.parseManifestRaw(current.raw);
-    const content = next === null ? store.ABSENCE_MARKER_RAW : `${JSON.stringify(next)}\n`;
-    const operation = await store.createOperation(context.stateDirectory, current, content, options.randomId ?? randomUUID, context.syncDirectory, options.afterIntentDurableBeforeActivate);
-    await options.afterStageDurable?.(join(operation.path, store.STAGE_BASENAME));
-    const reloaded = await store.loadOperation(operation.path);
-    const observed = await store.readStableFile(context.manifestPath, store.MAX_MANIFEST_BYTES);
-    if (!store.sameSnapshot(reloaded.intentSnapshot, operation.intentSnapshot)
-        || reloaded.stage === null
-        || !store.snapshotMatchesBinding(reloaded.stage, operation.intent.stage, false)
-        || (current === null ? observed !== null : observed === null || !store.sameSnapshot(current, observed))) {
-        await store.cleanupOperation(operation.path, context.syncDirectory);
-        return store.pathUnmanaged();
-    }
-    return Object.freeze({ agentRoot, operationId: operation.intent.nonce, previous, next });
-};
-export async function prepareAppliedProjectSkillManifestUpdate(agentRoot, manifest, options = {}) {
-    return prepareManifestTransition(agentRoot, store.parsePublishableAppliedProjectSkillManifest(manifest), options);
-}
-export async function prepareAppliedProjectSkillManifestRemoval(agentRoot, options = {}) {
-    return prepareManifestTransition(agentRoot, null, options);
-}
-/** Settles a durable standalone applied-manifest operation before current-state selection. */
-export async function recoverAppliedProjectSkillManifestUpdates(agentRoot, options = {}) {
-    await stateContext(agentRoot, options, true);
-}
-export async function publishPreparedProjectSkillManifestUpdate(update, options = {}) {
-    if (await completedWithoutOperation(update, update.next, options))
-        return;
-    const context = await loadBoundUpdate(update, options);
-    const { operation } = context;
-    const existing = await store.readStableFile(context.manifestPath, store.MAX_MANIFEST_BYTES);
-    if (update.next !== null
-        && existing !== null
-        && store.snapshotMatchesBinding(existing, operation.intent.stage, true))
-        return;
-    if (operation.intent.previous === null) {
-        if (existing !== null || operation.previous !== null)
-            return store.pathUnmanaged();
-    }
-    else if (operation.previous === null) {
-        if (existing === null || !store.snapshotMatchesBinding(existing, operation.intent.previous, true)) {
-            return store.pathUnmanaged();
-        }
-        await claimPublicManifest(context, store.PREVIOUS_BASENAME, operation.intent.previous, undefined, options.afterCurrentClaimed);
-    }
-    else if (existing !== null) {
-        return store.pathUnmanaged();
-    }
-    const publishable = await store.loadOperation(operation.path);
-    if (update.next === null && publishable.published !== null) {
-        if (existing !== null)
-            return store.pathUnmanaged();
-        return;
-    }
-    const stagePath = join(operation.path, store.STAGE_BASENAME);
-    const stage = await store.readStableFile(stagePath, store.MAX_MANIFEST_BYTES);
-    if (!store.sameSnapshot(publishable.intentSnapshot, operation.intentSnapshot)
-        || stage === null
-        || !store.snapshotMatchesBinding(stage, operation.intent.stage, false))
-        return store.pathUnmanaged();
-    if (update.next === null) {
-        try {
-            await link(stagePath, context.manifestPath);
-            await context.syncDirectory(context.stateDirectory);
-        }
-        catch (error) {
-            if (!store.isExisting(error))
-                return store.pathUnmanaged();
-        }
-        const claim = await store.readStableFile(context.manifestPath, store.MAX_MANIFEST_BYTES);
-        if (claim === null || !store.snapshotMatchesBinding(claim, operation.intent.stage, true)) {
-            return store.pathUnmanaged();
-        }
-        await claimPublicManifest(context, store.PUBLISHED_BASENAME, operation.intent.stage, options.afterRemovalMarkerPublished === undefined
-            ? undefined
-            : () => options.afterRemovalMarkerPublished(context.manifestPath));
-        return;
-    }
-    try {
-        await link(stagePath, context.manifestPath);
-        await context.syncDirectory(context.stateDirectory);
-    }
-    catch (error) {
-        if (!store.isExisting(error))
-            return store.pathUnmanaged();
-    }
-    const published = await store.readStableFile(context.manifestPath, store.MAX_MANIFEST_BYTES);
-    if (published === null
-        || !store.snapshotMatchesBinding(published, operation.intent.stage, true)
-        || published.identity.dev !== stage.identity.dev
-        || published.identity.ino !== stage.identity.ino)
-        return store.pathUnmanaged();
-}
-export async function commitPreparedProjectSkillManifestUpdate(update, options = {}) {
-    if (await completedWithoutOperation(update, update.next, options))
-        return;
-    const context = await loadBoundUpdate(update, options);
-    const published = await store.readStableFile(context.manifestPath, store.MAX_MANIFEST_BYTES);
-    const removalPublished = update.next === null
-        && published === null
-        && context.operation.published !== null;
-    if (!removalPublished && (published === null
-        || !store.snapshotMatchesBinding(published, context.operation.intent.stage, true))) {
-        return store.pathUnmanaged();
-    }
-    await store.cleanupOperation(context.operation.path, context.syncDirectory, options);
-}
-export async function rollbackPreparedProjectSkillManifestUpdate(update, options = {}) {
-    if (await completedWithoutOperation(update, update.previous, options))
-        return;
-    let context = await loadBoundUpdate(update, options);
-    let current = await store.readStableFile(context.manifestPath, store.MAX_MANIFEST_BYTES);
-    if (current !== null && store.snapshotMatchesBinding(current, context.operation.intent.stage, true)) {
-        try {
-            await lstat(join(context.operation.path, store.PUBLISHED_BASENAME));
-            return store.pathUnmanaged();
-        }
-        catch (error) {
-            if (error.code !== "ENOENT")
-                return store.pathUnmanaged();
-        }
-        await claimPublicManifest(context, store.PUBLISHED_BASENAME, context.operation.intent.stage, options.afterRollbackFinalCheck === undefined
-            ? undefined
-            : () => options.afterRollbackFinalCheck(context.manifestPath), options.afterRollbackUnknownClaimed === undefined
-            ? undefined
-            : (claimedPath) => options.afterRollbackUnknownClaimed(claimedPath, context.manifestPath), options.afterRollbackRestoreSlotChecked === undefined
-            ? undefined
-            : (claimedPath) => options.afterRollbackRestoreSlotChecked(claimedPath, context.manifestPath));
-        context = await loadBoundUpdate(update, options);
-        if (context.operation.published === null)
-            return store.pathUnmanaged();
-        current = null;
-    }
-    const previousBinding = context.operation.intent.previous;
-    if (previousBinding === null) {
-        if (current !== null)
-            return store.pathUnmanaged();
-    }
-    else if (current === null) {
-        await store.restorePreviousNoClobber(context.operation, context.manifestPath, context.stateDirectory, context.syncDirectory);
-    }
-    else if (!store.snapshotMatchesBinding(current, previousBinding, true)) {
-        return store.pathUnmanaged();
-    }
-    await store.cleanupOperation(context.operation.path, context.syncDirectory, options);
-}

package/dist/project-skills/projection-state.js

@@ -1,3 +0,0 @@
-export { computeProjectSkillBindingDigest, computeProjectSkillResolutionDigest, createAppliedProjectSkillManifest, normalizeProjectSkillResolutionRecords, ProjectSkillProjectionStateError, } from "./projection-state-domain.js";
-export { appliedProjectSkillManifestPath, readAppliedProjectSkillManifest, writeAppliedProjectSkillManifest, } from "./projection-state-store.js";
-export { commitPreparedProjectSkillManifestUpdate, parseProjectSkillManifestUpdateRecord, prepareAppliedProjectSkillManifestRemoval, prepareAppliedProjectSkillManifestUpdate, preparedProjectSkillManifestUpdateFromRecord, projectSkillManifestUpdateRecord, publishPreparedProjectSkillManifestUpdate, recoverAppliedProjectSkillManifestUpdates, rollbackPreparedProjectSkillManifestUpdate, } from "./projection-state-transaction.js";

package/dist/project-skills/runtime-root-bootstrap.js

@@ -1,47 +0,0 @@
-import { ProjectSkillRuntimeStoreError } from "./runtime-root-domain.js";
-/**
- * Generic startup hard gate. The callback is the only place a journal owner may be constructed or
- * initialized, and is unreachable until every durable lease inventory has populated the synchronous
- * retention snapshot. Task 9 wires this gate into `serve`; Task 5 deliberately does not advertise v2.
- */
-export async function initializeAfterProjectSkillLeaseProtection(input) {
-    const protectedExecutionIds = new Set();
-    for (const agentRoot of input.agentRoots) {
-        for (const executionId of await input.leases.protectedExecutionIds(agentRoot)) {
-            protectedExecutionIds.add(executionId);
-        }
-    }
-    return input.initialize(protectedExecutionIds);
-}
-/**
- * Runs only after execution-journal restart reconciliation has settled. A lease without a terminal
- * journal fact remains durable and prevents the caller from marking Project Skill v2 ready.
- */
-export async function recoverProjectSkillRuntimeRoots(input) {
-    for (const agentRoot of input.agentRoots) {
-        await input.roots.recover(agentRoot);
-        let unresolvedLease = false;
-        await input.leases.recover(agentRoot, async (executionId) => {
-            const entry = await input.journal.get(executionId);
-            const releasable = entry?.state === "completed" || entry?.state === "interrupted";
-            if (!releasable)
-                unresolvedLease = true;
-            return releasable;
-        });
-        if (unresolvedLease) {
-            throw new ProjectSkillRuntimeStoreError("skill_projection_snapshot_corrupt");
-        }
-    }
-    await input.afterLeaseRecovery?.();
-    for (const agentRoot of input.agentRoots) {
-        if (input.gc !== undefined && input.leases.list !== undefined && input.currentRootId !== undefined) {
-            const leased = await input.leases.list(agentRoot);
-            const currentRootId = await input.currentRootId(agentRoot);
-            await input.gc.collect(agentRoot, {
-                currentRootId,
-                leasedRootIds: leased.map(({ rootId }) => rootId),
-                keepHistory: 2,
-            }).catch(() => undefined);
-        }
-    }
-}

package/dist/project-skills/runtime-root-domain.js

@@ -1,268 +0,0 @@
-import { createHash } from "node:crypto";
-import { z } from "zod";
-import { compareProjectSkillRefs, isProjectId, isProjectSkillName, MAX_AGENT_PROJECT_SKILL_BINDINGS, MAX_PROJECT_ID_LENGTH, MAX_PROJECT_SKILL_NAME_LENGTH, } from "./types.js";
-const RUNTIME_ROOT_MANAGED_BY = "nowcrew-project-skill-runtime-root";
-const RUNTIME_STORE_MANAGED_BY = "nowcrew-project-skill-runtime-store";
-const RUNTIME_LEASE_MANAGED_BY = "nowcrew-project-skill-runtime-lease";
-const DIGEST = /^sha256:[a-f0-9]{64}$/u;
-const DECIMAL_BIGINT = /^(?:0|[1-9][0-9]*)$/u;
-const PATH_FREE_IDENTITY = /^[A-Za-z0-9][A-Za-z0-9._:-]*$/u;
-const CANONICAL_ROOT_ID = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/u;
-const MAX_LOCAL_IDENTITY_LENGTH = 512;
-const MAX_PUBLISHED_SEQUENCE = Number.MAX_SAFE_INTEGER - 1;
-/** Deployment algorithm/layout revision. This is deliberately not a source-content hash. */
-export const PROJECT_SKILL_RUNTIME_MATERIALIZATION_REVISION = 1;
-export class ProjectSkillRuntimeStoreError extends Error {
-    code;
-    constructor(code) {
-        super(code);
-        this.code = code;
-        this.name = "ProjectSkillRuntimeStoreError";
-    }
-}
-const corrupt = () => {
-    throw new ProjectSkillRuntimeStoreError("skill_projection_snapshot_corrupt");
-};
-const unmanaged = () => {
-    throw new ProjectSkillRuntimeStoreError("skill_projection_runtime_root_unmanaged");
-};
-const SafeSequenceSchema = z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER);
-const PublishedSequenceSchema = SafeSequenceSchema.max(MAX_PUBLISHED_SEQUENCE);
-const PositiveMaterializationRevisionSchema = z.number().int().positive().max(Number.MAX_SAFE_INTEGER);
-export const isCanonicalProjectSkillRuntimeRootId = (value) => CANONICAL_ROOT_ID.test(value);
-const RootIdSchema = z.string().refine(isCanonicalProjectSkillRuntimeRootId);
-const DigestSchema = z.string().regex(DIGEST);
-const DirectoryIdentitySchema = z.object({
-    dev: z.string().regex(DECIMAL_BIGINT),
-    ino: z.string().regex(DECIMAL_BIGINT),
-    birthtimeNs: z.string().regex(DECIMAL_BIGINT),
-}).strict();
-const ProjectionModeSchema = z.object({
-    projectId: z.string().min(1).max(MAX_PROJECT_ID_LENGTH),
-    skillName: z.string().min(1).max(MAX_PROJECT_SKILL_NAME_LENGTH),
-    mode: z.enum(["symlink", "junction", "copy", "missing"]),
-}).strict();
-const RuntimeRootManifestSchema = z.object({
-    managedBy: z.literal(RUNTIME_ROOT_MANAGED_BY),
-    version: z.literal(1),
-    rootId: RootIdSchema,
-    publishedSequence: PublishedSequenceSchema,
-    materializationRevision: PositiveMaterializationRevisionSchema,
-    directoryIdentity: DirectoryIdentitySchema,
-    bindingDigest: DigestSchema,
-    resolutionDigest: DigestSchema,
-    projectionModes: z.array(ProjectionModeSchema).max(MAX_AGENT_PROJECT_SKILL_BINDINGS),
-}).strict();
-const RuntimeRootManifestInputSchema = RuntimeRootManifestSchema
-    .omit({ managedBy: true, version: true, materializationRevision: true })
-    .partial({ publishedSequence: true, directoryIdentity: true });
-const RuntimeRootRecordSchema = z.object({
-    rootId: RootIdSchema,
-    publishedSequence: PublishedSequenceSchema,
-    materializationRevision: PositiveMaterializationRevisionSchema,
-    directoryIdentity: DirectoryIdentitySchema,
-    bindingDigest: DigestSchema,
-    resolutionDigest: DigestSchema,
-}).strict();
-const RuntimeStoreStateSchema = z.object({
-    managedBy: z.literal(RUNTIME_STORE_MANAGED_BY),
-    version: z.literal(1),
-    nextSequence: SafeSequenceSchema,
-    roots: z.array(RuntimeRootRecordSchema),
-}).strict();
-const RuntimeStoreStateInputSchema = RuntimeStoreStateSchema.omit({ managedBy: true, version: true });
-const PathFreeIdentitySchema = z.string()
-    .min(1)
-    .max(MAX_LOCAL_IDENTITY_LENGTH)
-    .regex(PATH_FREE_IDENTITY);
-const RuntimeLeaseRecordSchema = z.object({
-    managedBy: z.literal(RUNTIME_LEASE_MANAGED_BY),
-    version: z.literal(1),
-    executionId: PathFreeIdentitySchema,
-    rootId: RootIdSchema,
-    nonce: PathFreeIdentitySchema,
-}).strict();
-const RuntimeLeaseRecordInputSchema = RuntimeLeaseRecordSchema.omit({ managedBy: true, version: true });
-const immutableDirectoryIdentity = (identity) => Object.freeze({
-    dev: identity.dev,
-    ino: identity.ino,
-    birthtimeNs: identity.birthtimeNs,
-});
-const sameProjectionRef = (left, right) => left.projectId === right.projectId && left.skillName === right.skillName;
-const immutableProjectionMode = (projection) => Object.freeze({
-    projectId: projection.projectId,
-    skillName: projection.skillName,
-    mode: projection.mode,
-});
-const canonicalProjectionModes = (modes) => {
-    const seen = new Set();
-    const canonical = modes.map((mode) => {
-        if (!isProjectId(mode.projectId) || !isProjectSkillName(mode.skillName))
-            return corrupt();
-        const key = `${mode.projectId}\0${mode.skillName}`;
-        if (seen.has(key))
-            return corrupt();
-        seen.add(key);
-        return immutableProjectionMode(mode);
-    }).sort(compareProjectSkillRefs);
-    return Object.freeze(canonical);
-};
-const requireCanonicalProjectionModes = (modes) => {
-    const canonical = canonicalProjectionModes(modes);
-    if (canonical.some((mode, index) => {
-        const input = modes[index];
-        return input === undefined || !sameProjectionRef(mode, input) || mode.mode !== input.mode;
-    }))
-        return corrupt();
-    return canonical;
-};
-const immutableRootRecord = (record) => Object.freeze({
-    rootId: record.rootId,
-    publishedSequence: record.publishedSequence,
-    materializationRevision: record.materializationRevision,
-    directoryIdentity: immutableDirectoryIdentity(record.directoryIdentity),
-    bindingDigest: record.bindingDigest,
-    resolutionDigest: record.resolutionDigest,
-});
-const compareRootRecords = (left, right) => left.publishedSequence - right.publishedSequence
-    || (left.rootId < right.rootId ? -1 : left.rootId > right.rootId ? 1 : 0);
-const canonicalRootRecords = (records) => {
-    const rootIds = new Set();
-    const sequences = new Set();
-    const canonical = records.map((record) => {
-        const parsed = RuntimeRootRecordSchema.safeParse(record);
-        if (!parsed.success)
-            return corrupt();
-        if (rootIds.has(parsed.data.rootId) || sequences.has(parsed.data.publishedSequence))
-            return corrupt();
-        rootIds.add(parsed.data.rootId);
-        sequences.add(parsed.data.publishedSequence);
-        return immutableRootRecord(parsed.data);
-    }).sort(compareRootRecords);
-    return Object.freeze(canonical);
-};
-const requireCanonicalRootRecords = (records) => {
-    const canonical = canonicalRootRecords(records);
-    if (canonical.some((record, index) => {
-        const input = records[index];
-        return input === undefined
-            || record.rootId !== input.rootId
-            || record.publishedSequence !== input.publishedSequence;
-    }))
-        return corrupt();
-    return canonical;
-};
-const requireNextSequence = (nextSequence, roots) => {
-    const latest = roots.at(-1);
-    if (latest !== undefined && latest.publishedSequence >= nextSequence)
-        corrupt();
-};
-const rejectUnknownOwner = (candidate, expected) => {
-    if (candidate && typeof candidate === "object" && "managedBy" in candidate
-        && candidate.managedBy !== expected)
-        unmanaged();
-};
-export function createProjectSkillRuntimeRootManifest(input) {
-    const parsedInput = RuntimeRootManifestInputSchema.safeParse(input);
-    if (!parsedInput.success)
-        return corrupt();
-    const candidate = RuntimeRootManifestSchema.safeParse({
-        managedBy: RUNTIME_ROOT_MANAGED_BY,
-        version: 1,
-        rootId: parsedInput.data.rootId,
-        publishedSequence: parsedInput.data.publishedSequence ?? 0,
-        materializationRevision: PROJECT_SKILL_RUNTIME_MATERIALIZATION_REVISION,
-        directoryIdentity: parsedInput.data.directoryIdentity ?? { dev: "0", ino: "0", birthtimeNs: "0" },
-        bindingDigest: parsedInput.data.bindingDigest,
-        resolutionDigest: parsedInput.data.resolutionDigest,
-        projectionModes: parsedInput.data.projectionModes,
-    });
-    if (!candidate.success)
-        return corrupt();
-    return Object.freeze({
-        ...candidate.data,
-        directoryIdentity: immutableDirectoryIdentity(candidate.data.directoryIdentity),
-        projectionModes: canonicalProjectionModes(candidate.data.projectionModes),
-    });
-}
-export function parseProjectSkillRuntimeRootManifest(candidate) {
-    rejectUnknownOwner(candidate, RUNTIME_ROOT_MANAGED_BY);
-    const parsed = RuntimeRootManifestSchema.safeParse(candidate);
-    if (!parsed.success)
-        return corrupt();
-    return Object.freeze({
-        ...parsed.data,
-        directoryIdentity: immutableDirectoryIdentity(parsed.data.directoryIdentity),
-        projectionModes: requireCanonicalProjectionModes(parsed.data.projectionModes),
-    });
-}
-export function createProjectSkillRuntimeRootRecord(input) {
-    const parsed = RuntimeRootRecordSchema.safeParse(input);
-    if (!parsed.success)
-        return corrupt();
-    return immutableRootRecord(parsed.data);
-}
-export function parseProjectSkillRuntimeRootRecord(candidate) {
-    const parsed = RuntimeRootRecordSchema.safeParse(candidate);
-    if (!parsed.success)
-        return corrupt();
-    return immutableRootRecord(parsed.data);
-}
-export function createProjectSkillRuntimeStoreState(input) {
-    const parsedInput = RuntimeStoreStateInputSchema.safeParse(input);
-    if (!parsedInput.success)
-        return corrupt();
-    const parsed = RuntimeStoreStateSchema.safeParse({
-        managedBy: RUNTIME_STORE_MANAGED_BY,
-        version: 1,
-        nextSequence: parsedInput.data.nextSequence,
-        roots: parsedInput.data.roots,
-    });
-    if (!parsed.success)
-        return corrupt();
-    const roots = canonicalRootRecords(parsed.data.roots);
-    requireNextSequence(parsed.data.nextSequence, roots);
-    return Object.freeze({
-        managedBy: RUNTIME_STORE_MANAGED_BY,
-        version: 1,
-        nextSequence: parsed.data.nextSequence,
-        roots,
-    });
-}
-export function parseProjectSkillRuntimeStoreState(candidate) {
-    rejectUnknownOwner(candidate, RUNTIME_STORE_MANAGED_BY);
-    const parsed = RuntimeStoreStateSchema.safeParse(candidate);
-    if (!parsed.success)
-        return corrupt();
-    const roots = requireCanonicalRootRecords(parsed.data.roots);
-    requireNextSequence(parsed.data.nextSequence, roots);
-    return Object.freeze({
-        managedBy: RUNTIME_STORE_MANAGED_BY,
-        version: 1,
-        nextSequence: parsed.data.nextSequence,
-        roots,
-    });
-}
-export function createProjectSkillRuntimeLeaseRecord(input) {
-    const parsedInput = RuntimeLeaseRecordInputSchema.safeParse(input);
-    if (!parsedInput.success)
-        return corrupt();
-    const parsed = RuntimeLeaseRecordSchema.safeParse({
-        managedBy: RUNTIME_LEASE_MANAGED_BY,
-        version: 1,
-        ...parsedInput.data,
-    });
-    if (!parsed.success)
-        return corrupt();
-    return Object.freeze(parsed.data);
-}
-export function parseProjectSkillRuntimeLeaseRecord(candidate) {
-    rejectUnknownOwner(candidate, RUNTIME_LEASE_MANAGED_BY);
-    const parsed = RuntimeLeaseRecordSchema.safeParse(candidate);
-    if (!parsed.success)
-        return corrupt();
-    return Object.freeze(parsed.data);
-}
-export function projectSkillRuntimeLeaseKey(executionId) {
-    return createHash("sha256").update(executionId, "utf8").digest("hex");
-}