@nowcrew/daemon 0.6.16 → 0.6.18

package/dist/project-skills/reconciler.js

@@ -1,7 +1,12 @@
-import { cp, lstat, mkdir, readdir, readlink, rename, rm, stat, symlink, writeFile } from "node:fs/promises";
+import { cp, lstat, mkdir, readdir, readlink, stat, symlink, writeFile } from "node:fs/promises";
 import { randomUUID } from "node:crypto";
-import { dirname, join, resolve, sep } from "node:path";
+import { dirname, join, posix, win32 } from "node:path";
+import { isManagedDirectoryProjectionCopy, projectDirectory, } from "../directory-projection.js";
 import { runtimeProjectionLifetime, } from "./agent-projection-coordinator.js";
+import { commitPreparedProjectSkillManifestUpdate, computeProjectSkillBindingDigest, createAppliedProjectSkillManifest, prepareAppliedProjectSkillManifestRemoval, prepareAppliedProjectSkillManifestUpdate, publishPreparedProjectSkillManifestUpdate, readAppliedProjectSkillManifest, rollbackPreparedProjectSkillManifestUpdate, } from "./projection-state.js";
+import { compareProjectSkillRefs, } from "./types.js";
+import { projectSkillProjectionExpectation, projectSkillResolutionRecords, } from "./scanner.js";
+import { cleanupProjectionStaging, isManagedProjectionRoot, markProjectionStaging, PROJECTION_ROOT_MARKER_NAME, projectionTargets, recoverProjectionSwitch, switchProjectionSet, } from "./projection-set-switch.js";
 export class ProjectProjectionError extends Error {
     code;
     constructor(code) {
@@ -10,21 +15,72 @@ export class ProjectProjectionError extends Error {
         this.name = "ProjectProjectionError";
     }
 }
+export const decideProjectSkillProjection = (expected, applied) => {
+    if (applied === null || expected.generation > applied.generation) {
+        return Object.freeze({ kind: "ensure-applied" });
+    }
+    if (expected.generation < applied.generation) {
+        return Object.freeze({ kind: "use-advanced", warning: "skill_projection_advanced" });
+    }
+    if (expected.bindingDigest !== applied.bindingDigest) {
+        return Object.freeze({ kind: "reject", code: "skill_projection_snapshot_corrupt" });
+    }
+    return expected.resolutionDigest === applied.resolutionDigest
+        ? Object.freeze({ kind: "use-current" })
+        : Object.freeze({ kind: "ensure-applied" });
+};
 const exists = async (path) => lstat(path).then(() => true, () => false);
-const preserveNonProjectSkills = async (target, staging, trainingSkillsRoot) => {
+const normalizeWindowsLinkIdentity = (value) => {
+    if (/^\\\\\?\\UNC\\/iu.test(value))
+        return `\\\\${value.slice(8)}`;
+    if (/^\\\\\?\\[A-Za-z]:\\/u.test(value))
+        return value.slice(4);
+    return value;
+};
+const isSameOrWithin = (root, candidate, path) => {
+    const relative = path.relative(root, candidate);
+    return relative === ""
+        || (relative !== ".." && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative));
+};
+export const canonicalTrainingSkillLinkTarget = (source, link, trainingSkillsRoot, platform) => {
+    const path = platform === "win32" ? win32 : posix;
+    const normalizedSource = platform === "win32" ? normalizeWindowsLinkIdentity(source) : source;
+    const normalizedLink = platform === "win32" ? normalizeWindowsLinkIdentity(link) : link;
+    const normalizedTrainingRoot = platform === "win32"
+        ? normalizeWindowsLinkIdentity(trainingSkillsRoot)
+        : trainingSkillsRoot;
+    const resolvedLink = path.resolve(path.dirname(normalizedSource), normalizedLink);
+    return isSameOrWithin(path.normalize(normalizedTrainingRoot), resolvedLink, path)
+        ? path.normalize(resolvedLink)
+        : null;
+};
+export const isTrainingSkillLink = (source, link, trainingSkillsRoot, platform) => canonicalTrainingSkillLinkTarget(source, link, trainingSkillsRoot, platform) !== null;
+const preserveNonProjectSkills = async (projectionTarget, trainingSkillsRoot, platform) => {
     const names = new Set();
-    if (!await exists(target))
+    if (!await exists(projectionTarget.target))
         return names;
-    for (const entry of await readdir(target, { withFileTypes: true })) {
-        const source = join(target, entry.name);
-        const destination = join(staging, entry.name);
+    const rootInfo = await lstat(projectionTarget.target);
+    if (!rootInfo.isDirectory() || rootInfo.isSymbolicLink()) {
+        throw new ProjectProjectionError("skill_projection_failed");
+    }
+    const managedRoot = await isManagedProjectionRoot(projectionTarget.target, projectionTarget);
+    for (const entry of await readdir(projectionTarget.target, { withFileTypes: true })) {
+        if (entry.name === PROJECTION_ROOT_MARKER_NAME) {
+            if (managedRoot)
+                continue;
+            throw new ProjectProjectionError("skill_projection_failed");
+        }
+        const source = join(projectionTarget.target, entry.name);
+        const destination = join(projectionTarget.staging, entry.name);
+        if (platform === "win32" && await isManagedDirectoryProjectionCopy(source, platform))
+            continue;
         const info = await lstat(source);
         if (info.isSymbolicLink()) {
             const link = await readlink(source);
-            const resolvedLink = resolve(dirname(source), link);
-            if (resolvedLink !== trainingSkillsRoot && !resolvedLink.startsWith(`${trainingSkillsRoot}${sep}`))
+            const canonicalTarget = canonicalTrainingSkillLinkTarget(source, link, trainingSkillsRoot, platform);
+            if (canonicalTarget === null)
                 continue;
-            await symlink(link, destination, "dir");
+            await symlink(platform === "win32" ? canonicalTarget : link, destination, platform === "win32" ? "junction" : "dir");
         }
         else {
             await cp(source, destination, { recursive: true, preserveTimestamps: true });
@@ -33,41 +89,39 @@ const preserveNonProjectSkills = async (target, staging, trainingSkillsRoot) =>
     }
     return names;
 };
-async function switchProjectionSet(targets) {
-    const moved = [];
-    try {
-        for (const target of targets) {
-            const hadPrevious = await exists(target.target);
-            if (hadPrevious)
-                await rename(target.target, target.backup);
-            const state = { target, hadPrevious, activated: false };
-            moved.push(state);
-            await rename(target.staging, target.target);
-            state.activated = true;
-        }
-    }
-    catch (error) {
-        for (const state of [...moved].reverse()) {
-            if (state.activated)
-                await rm(state.target.target, { recursive: true, force: true }).catch(() => { });
-            if (state.hadPrevious)
-                await rename(state.target.backup, state.target.target).catch(() => { });
-        }
-        throw error;
-    }
-    await Promise.all(targets.map((target) => rm(target.backup, { recursive: true, force: true })));
-}
 export function createProjectSkillsReconciler(deps) {
     const platform = deps.platform ?? process.platform;
-    const reconcileUnlocked = async (handle, bindings) => {
-        if (platform !== "darwin" && platform !== "linux") {
-            throw new ProjectProjectionError("skill_projection_failed");
+    const directoryProjector = deps.projectDirectory ?? projectDirectory;
+    const readOptions = { platform };
+    const readApplied = deps.readAppliedManifest ?? readAppliedProjectSkillManifest;
+    const prepareRemoval = deps.prepareAppliedManifestRemoval ?? prepareAppliedProjectSkillManifestRemoval;
+    const prepareUpdate = deps.prepareAppliedManifestUpdate ?? prepareAppliedProjectSkillManifestUpdate;
+    const publishUpdate = deps.publishAppliedManifestUpdate
+        ?? ((update) => publishPreparedProjectSkillManifestUpdate(update, readOptions));
+    const commitUpdate = deps.commitAppliedManifestUpdate
+        ?? ((update) => commitPreparedProjectSkillManifestUpdate(update, readOptions));
+    const rollbackUpdate = deps.rollbackAppliedManifestUpdate
+        ?? ((update) => rollbackPreparedProjectSkillManifestUpdate(update, readOptions));
+    const manifestOperations = Object.freeze({
+        publish: publishUpdate,
+        commit: commitUpdate,
+        rollback: rollbackUpdate,
+    });
+    let lastProjectionDiagnostics = Object.freeze([]);
+    const reconcileUnlocked = async (handle, bindings, projects = deps.scannedProjects(), recover = true, manifestPublication) => {
+        const agentRoot = join(deps.agentsRoot, handle);
+        if (recover) {
+            try {
+                await recoverProjectionSwitch(agentRoot, deps.syncDirectory);
+            }
+            catch {
+                throw new ProjectProjectionError("skill_projection_failed");
+            }
         }
-        const projects = deps.scannedProjects();
         const uniqueBindings = [...new Map(bindings.map((binding) => [
                 `${binding.projectId}\0${binding.skillName}`,
                 binding,
-            ])).values()].sort((left, right) => left.projectId.localeCompare(right.projectId) || left.skillName.localeCompare(right.skillName));
+            ])).values()].sort(compareProjectSkillRefs);
         const names = new Map();
         for (const binding of uniqueBindings) {
             const owner = names.get(binding.skillName);
@@ -78,68 +132,245 @@ export function createProjectSkillsReconciler(deps) {
         }
         const linked = [];
         const resolutions = [];
+        const resolutionRecords = [];
         for (const binding of uniqueBindings) {
             const project = projects.find((candidate) => candidate.inventory.projectId === binding.projectId
                 && candidate.inventory.status === "available");
             const skill = project?.resolved.find((candidate) => candidate.name === binding.skillName);
             const available = skill !== undefined && (await stat(skill.sourcePath).catch(() => null))?.isDirectory() === true;
             resolutions.push(Object.freeze({ ...binding, status: available ? "linked" : "unavailable" }));
-            if (available && skill !== undefined)
+            if (available && skill !== undefined) {
                 linked.push({ binding, skill });
+                resolutionRecords.push(Object.freeze({
+                    ...binding,
+                    sourcePath: skill.sourcePath,
+                    mode: "resolved",
+                }));
+            }
+            else {
+                resolutionRecords.push(Object.freeze({ ...binding, sourcePath: null, mode: "missing" }));
+            }
         }
-        const agentRoot = join(deps.agentsRoot, handle);
         const id = randomUUID();
-        const targets = [
-            {
-                runtime: "codex",
-                target: join(agentRoot, ".agents", "skills"),
-                staging: join(agentRoot, ".agents", `.skills-next-${id}`),
-                backup: join(agentRoot, ".agents", `.skills-previous-${id}`),
-            },
-            {
-                runtime: "claude",
-                target: join(agentRoot, ".crew", "claude-skills", ".claude", "skills"),
-                staging: join(agentRoot, ".crew", "claude-skills", ".claude", `.skills-next-${id}`),
-                backup: join(agentRoot, ".crew", "claude-skills", ".claude", `.skills-previous-${id}`),
-            },
-        ];
+        const targets = projectionTargets(agentRoot, id);
+        const nextProjectionDiagnostics = [];
         try {
             for (const target of targets) {
                 await mkdir(dirname(target.target), { recursive: true });
                 await mkdir(target.staging, { mode: 0o700 });
-                const preservedNames = await preserveNonProjectSkills(target.target, target.staging, join(agentRoot, "training", "skills"));
+                await markProjectionStaging(target, id);
+                const preservedNames = await preserveNonProjectSkills(target, join(agentRoot, "training", "skills"), platform);
                 for (const item of linked) {
                     if (preservedNames.has(item.binding.skillName)) {
                         throw new ProjectProjectionError("skill_name_conflict");
                     }
-                    await symlink(item.skill.sourcePath, join(target.staging, item.binding.skillName), "dir");
+                    const projectionTarget = join(target.staging, item.binding.skillName);
+                    const projection = await directoryProjector(item.skill.sourcePath, projectionTarget, platform, { finalTarget: join(target.target, item.binding.skillName) });
+                    nextProjectionDiagnostics.push(Object.freeze({
+                        runtime: target.runtime,
+                        projectId: item.binding.projectId,
+                        skillName: item.binding.skillName,
+                        mode: projection.mode,
+                        ...(projection.copyProtection === undefined
+                            ? {}
+                            : { copyProtection: projection.copyProtection }),
+                    }));
                 }
             }
+            await writeFile(join(agentRoot, ".nowwork-root"), "", { encoding: "utf8", mode: 0o600 });
             for (const target of targets)
                 await deps.beforeSwitch?.(target.runtime);
-            await switchProjectionSet(targets);
-            await writeFile(join(agentRoot, ".nowwork-root"), "", { encoding: "utf8", mode: 0o600 });
-            return Object.freeze(resolutions);
+            const publication = await manifestPublication?.(Object.freeze(resolutionRecords));
+            await switchProjectionSet(agentRoot, targets, id, deps.switchFault, deps.syncDirectory, publication);
+            lastProjectionDiagnostics = Object.freeze(nextProjectionDiagnostics);
+            return Object.freeze({
+                resolutions: Object.freeze(resolutions),
+                resolutionRecords: Object.freeze(resolutionRecords),
+            });
         }
         catch (error) {
-            await Promise.all(targets.map((target) => rm(target.staging, { recursive: true, force: true })));
+            try {
+                await Promise.all(targets.map((target) => cleanupProjectionStaging(target, id, deps.syncDirectory)));
+            }
+            catch {
+                throw new ProjectProjectionError("skill_projection_failed");
+            }
             if (error instanceof ProjectProjectionError)
                 throw error;
             throw new ProjectProjectionError("skill_projection_failed");
         }
     };
+    const validateExpectation = (expected) => {
+        const canonical = [...expected.bindings].sort(compareProjectSkillRefs);
+        const isCanonical = canonical.length === expected.bindings.length
+            && canonical.every((binding, index) => binding.projectId === expected.bindings[index]?.projectId
+                && binding.skillName === expected.bindings[index]?.skillName)
+            && canonical.every((binding, index) => index === 0
+                || binding.projectId !== canonical[index - 1]?.projectId
+                || binding.skillName !== canonical[index - 1]?.skillName);
+        const digestShape = /^sha256:[a-f0-9]{64}$/u;
+        let bindingDigestMatches = false;
+        try {
+            bindingDigestMatches = computeProjectSkillBindingDigest(expected.bindings) === expected.bindingDigest;
+        }
+        catch {
+            bindingDigestMatches = false;
+        }
+        if (!isCanonical
+            || !Number.isInteger(expected.generation)
+            || expected.generation < 0
+            || expected.generation > 2_147_483_647
+            || !digestShape.test(expected.resolutionDigest)
+            || !bindingDigestMatches) {
+            throw new ProjectProjectionError("skill_projection_snapshot_corrupt");
+        }
+    };
+    const rejectDecision = (decision) => {
+        if (decision.kind === "reject")
+            throw new ProjectProjectionError(decision.code);
+    };
+    const ensureAppliedLocked = async (handle, expected, projectsSnapshot) => {
+        const agentRoot = join(deps.agentsRoot, handle);
+        try {
+            await recoverProjectionSwitch(agentRoot, deps.syncDirectory, manifestOperations);
+        }
+        catch {
+            throw new ProjectProjectionError("skill_projection_failed");
+        }
+        const current = await readApplied(agentRoot, readOptions);
+        const lockedDecision = decideProjectSkillProjection(expected, current);
+        rejectDecision(lockedDecision);
+        if (lockedDecision.kind !== "ensure-applied")
+            return lockedDecision;
+        const projects = projectsSnapshot ?? deps.scannedProjects();
+        const reconciled = await reconcileUnlocked(handle, expected.bindings, projects, false, async (records) => {
+            const applied = createAppliedProjectSkillManifest({
+                bindings: expected.bindings,
+                generation: expected.generation,
+                resolutions: records,
+                platform,
+            });
+            const lockedExpectation = Object.freeze({
+                bindings: expected.bindings,
+                generation: expected.generation,
+                bindingDigest: expected.bindingDigest,
+                resolutionDigest: applied.resolutionDigest,
+            });
+            const update = await prepareUpdate(agentRoot, applied, readOptions);
+            return Object.freeze({
+                update,
+                operations: manifestOperations,
+                verify: async () => {
+                    const rechecked = await readApplied(agentRoot, readOptions);
+                    const finalDecision = decideProjectSkillProjection(lockedExpectation, rechecked);
+                    rejectDecision(finalDecision);
+                    if (finalDecision.kind !== "use-current") {
+                        throw new ProjectProjectionError("skill_projection_failed");
+                    }
+                },
+                ...(deps.afterManifestPublishedBeforeCommit === undefined
+                    ? {}
+                    : { afterPublishedBeforeCommit: deps.afterManifestPublishedBeforeCommit }),
+                ...(deps.unlinkSwitchJournal === undefined
+                    ? {}
+                    : { unlinkJournal: deps.unlinkSwitchJournal }),
+            });
+        });
+        const warnings = reconciled.resolutions
+            .filter((resolution) => resolution.status === "unavailable")
+            .map((resolution) => Object.freeze({
+            projectId: resolution.projectId,
+            skillName: resolution.skillName,
+            code: "project_skill_unavailable",
+        }));
+        return warnings.length === 0
+            ? Object.freeze({ kind: "ensure-applied" })
+            : Object.freeze({ kind: "ensure-applied", warnings: Object.freeze(warnings) });
+    };
+    const ensureApplied = async (handle, expected) => {
+        validateExpectation(expected);
+        return deps.coordinator.runExclusive(deps.agentsRoot, handle, () => ensureAppliedLocked(handle, expected));
+    };
+    const ensureSnapshot = async (handle, snapshot) => deps.coordinator.runExclusive(deps.agentsRoot, handle, async () => {
+        const projects = deps.scannedProjects();
+        let expected;
+        try {
+            expected = projectSkillProjectionExpectation(snapshot, projects, platform);
+            validateExpectation(expected);
+        }
+        catch (error) {
+            if (error instanceof ProjectProjectionError)
+                throw error;
+            throw new ProjectProjectionError("skill_projection_snapshot_corrupt");
+        }
+        const decision = await ensureAppliedLocked(handle, expected, projects);
+        if (decision.kind !== "use-current")
+            return decision;
+        const warnings = projectSkillResolutionRecords(snapshot.bindings, projects, platform)
+            .filter((record) => record.mode === "missing")
+            .map((record) => Object.freeze({
+            projectId: record.projectId,
+            skillName: record.skillName,
+            code: "project_skill_unavailable",
+        }));
+        return warnings.length === 0
+            ? decision
+            : Object.freeze({ kind: "use-current", warnings: Object.freeze(warnings) });
+    });
+    const reconcileLegacyUnlocked = async (handle, bindings) => {
+        const agentRoot = join(deps.agentsRoot, handle);
+        try {
+            await recoverProjectionSwitch(agentRoot, deps.syncDirectory, manifestOperations);
+        }
+        catch {
+            throw new ProjectProjectionError("skill_projection_failed");
+        }
+        return reconcileUnlocked(handle, bindings, deps.scannedProjects(), false, async () => {
+            const update = await prepareRemoval(agentRoot, readOptions);
+            return Object.freeze({
+                update,
+                operations: manifestOperations,
+                verify: async () => {
+                    if (await readApplied(agentRoot, readOptions) !== null) {
+                        throw new ProjectProjectionError("skill_projection_failed");
+                    }
+                },
+                ...(deps.afterManifestPublishedBeforeCommit === undefined
+                    ? {}
+                    : { afterPublishedBeforeCommit: deps.afterManifestPublishedBeforeCommit }),
+                ...(deps.unlinkSwitchJournal === undefined
+                    ? {}
+                    : { unlinkJournal: deps.unlinkSwitchJournal }),
+            });
+        });
+    };
     return {
         reconcile(handle, bindings) {
-            return deps.coordinator.runExclusive(deps.agentsRoot, handle, () => reconcileUnlocked(handle, bindings));
+            return deps.coordinator.runExclusive(deps.agentsRoot, handle, async () => (await reconcileLegacyUnlocked(handle, bindings)).resolutions);
         },
-        prepareAndLaunch(agentsRoot, handle, bindings, launch) {
+        ensureSnapshot,
+        ensureApplied,
+        projectionDiagnostics: () => lastProjectionDiagnostics,
+        async prepareAndLaunch(agentsRoot, handle, projection, launch, onWarning) {
             if (agentsRoot !== deps.agentsRoot) {
-                return Promise.reject(new ProjectProjectionError("skill_projection_failed"));
+                throw new ProjectProjectionError("skill_projection_failed");
+            }
+            if (Array.isArray(projection)) {
+                return deps.coordinator.runExclusiveUntil(deps.agentsRoot, handle, async () => {
+                    await reconcileLegacyUnlocked(handle, projection);
+                    return launch();
+                }, runtimeProjectionLifetime);
+            }
+            const decision = "resolutionDigest" in projection
+                ? await ensureApplied(handle, projection)
+                : await ensureSnapshot(handle, projection);
+            if (decision.kind === "use-advanced")
+                onWarning?.({ code: decision.warning });
+            if ("warnings" in decision) {
+                for (const warning of decision.warnings ?? [])
+                    onWarning?.(warning);
             }
-            return deps.coordinator.runExclusiveUntil(deps.agentsRoot, handle, async () => {
-                await reconcileUnlocked(handle, bindings);
-                return launch();
-            }, runtimeProjectionLifetime);
+            return launch();
         },
     };
 }

package/dist/project-skills/runtime-warning.js

@@ -0,0 +1,6 @@
+/** Stable, path-free console text; only logical IDs from the server snapshot are included. */
+export function formatProjectSkillRuntimeWarning(warning) {
+    return warning.code === "skill_projection_advanced"
+        ? "[runtime-warning] skill_projection_advanced"
+        : `[runtime-warning] project_skill_unavailable project=${warning.projectId} skill=${warning.skillName}`;
+}

package/dist/project-skills/scanner.js

@@ -1,7 +1,8 @@
 import { readdir, readFile, stat } from "node:fs/promises";
 import { join } from "node:path";
-import { isProjectSkillName, MAX_MACHINE_PROJECT_SKILLS, MAX_PROJECT_SKILL_DESCRIPTION_LENGTH, MAX_PROJECT_SKILL_FILE_BYTES, MAX_PROJECT_SKILLS_PER_PROJECT, } from "./types.js";
+import { compareProjectSkillRefs, isProjectSkillName, MAX_MACHINE_PROJECT_SKILLS, MAX_PROJECT_SKILL_DESCRIPTION_LENGTH, MAX_PROJECT_SKILL_FILE_BYTES, MAX_PROJECT_SKILLS_PER_PROJECT, } from "./types.js";
 import { parseSkillFrontmatter } from "../skill-frontmatter.js";
+import { computeProjectSkillBindingDigest, computeProjectSkillResolutionDigest, normalizeProjectSkillResolutionRecords, } from "./projection-state.js";
 const unavailable = (projectId, scannedAt, errorCode) => Object.freeze({
     inventory: Object.freeze({
         projectId,
@@ -130,3 +131,31 @@ export async function scanProjects(projects, now = () => new Date(), retainedPro
     const sorted = [...projects].sort((left, right) => left.projectId.localeCompare(right.projectId));
     return boundScannedProjects(await Promise.all(sorted.map((project) => scanProject(project, now))), retainedProjectIds);
 }
+/** V2-only source identity mapper; existing v1 inventory and resolved scan shapes remain unchanged. */
+export function projectSkillResolutionRecords(bindings, projects, platform = process.platform) {
+    const records = [...bindings].sort(compareProjectSkillRefs).map((binding) => {
+        const project = projects.find((candidate) => candidate.inventory.projectId === binding.projectId
+            && candidate.inventory.status === "available");
+        const skill = project?.resolved.find((candidate) => candidate.name === binding.skillName);
+        return skill === undefined
+            ? Object.freeze({ ...binding, sourcePath: null, mode: "missing" })
+            : Object.freeze({ ...binding, sourcePath: skill.sourcePath, mode: "resolved" });
+    });
+    return normalizeProjectSkillResolutionRecords(records, platform);
+}
+/** Daemon-local expectation derived from one immutable scanner snapshot; no path crosses the wire. */
+export function projectSkillProjectionExpectation(snapshot, projects, platform = process.platform) {
+    const bindings = Object.freeze(snapshot.bindings
+        .map((binding) => Object.freeze({
+        projectId: binding.projectId,
+        skillName: binding.skillName,
+    }))
+        .sort(compareProjectSkillRefs));
+    const resolutions = projectSkillResolutionRecords(bindings, projects, platform);
+    return Object.freeze({
+        bindings,
+        generation: snapshot.generation,
+        bindingDigest: computeProjectSkillBindingDigest(bindings),
+        resolutionDigest: computeProjectSkillResolutionDigest(resolutions, platform),
+    });
+}

package/dist/project-skills/types.js

@@ -11,3 +11,12 @@ const PROJECT_ID = /^[a-z0-9][a-z0-9._-]*$/u;
 const SKILL_NAME = /^[a-z0-9][a-z0-9._:-]*$/u;
 export const isProjectId = (value) => value.length > 0 && value.length <= MAX_PROJECT_ID_LENGTH && PROJECT_ID.test(value);
 export const isProjectSkillName = (value) => value.length > 0 && value.length <= MAX_PROJECT_SKILL_NAME_LENGTH && SKILL_NAME.test(value);
+const compareBinary = (left, right) => {
+    if (left < right)
+        return -1;
+    if (left > right)
+        return 1;
+    return 0;
+};
+export const compareProjectSkillRefs = (left, right) => compareBinary(left.projectId, right.projectId)
+    || compareBinary(left.skillName, right.skillName);