@dailephd/my-dev-kit-lab 0.4.2 → 0.4.3

package/dist/src/evaluation/stageContextSelectors/contextCapsuleSelectors.js

@@ -0,0 +1,126 @@
+export function selectContextCapsuleSchemaVersion(artifact) {
+    return artifact.schemaVersion;
+}
+export function selectContextCapsuleGeneratedAt(artifact) {
+    return artifact.generatedAt;
+}
+export function selectContextCapsuleTool(artifact) {
+    return artifact.tool;
+}
+export function selectContextCapsuleRequest(artifact) {
+    return artifact.request;
+}
+export function selectContextCapsuleIndex(artifact) {
+    return artifact.index;
+}
+export function selectContextCapsuleLimits(artifact) {
+    return artifact.limits;
+}
+export function selectContextCapsuleRequiredContext(artifact) {
+    return artifact.requiredContext;
+}
+export function selectContextCapsuleOptionalSupportContext(artifact) {
+    return artifact.optionalSupportContext;
+}
+export function selectContextCapsuleDroppedContext(artifact) {
+    return artifact.droppedContext;
+}
+export function selectContextCapsuleWarnings(artifact) {
+    return artifact.warnings;
+}
+export function selectContextCapsuleContextAdequacy(artifact) {
+    return artifact.contextAdequacy;
+}
+export function selectContextCapsuleQueryPlan(artifact) {
+    return artifact.queryPlan;
+}
+export function selectContextCapsuleCandidateFiles(artifact) {
+    return artifact.candidateFiles;
+}
+export function selectContextCapsuleCandidateNodes(artifact) {
+    return artifact.candidateNodes;
+}
+export function selectContextCapsuleFocus(artifact) {
+    return artifact.focus;
+}
+export function selectContextCapsuleSelectedGraph(artifact) {
+    return artifact.selectedGraph;
+}
+export function selectContextCapsuleRetention(artifact) {
+    return artifact.retention;
+}
+export function selectContextCapsuleSelectedSource(artifact) {
+    return artifact.selectedSource;
+}
+export function selectContextCapsuleSelectedSourceBundles(artifact) {
+    return artifact.selectedSourceBundles;
+}
+export function selectContextCapsuleSemanticSummary(artifact) {
+    return artifact.semanticSummary;
+}
+export function selectContextCapsuleClassificationSummary(artifact) {
+    return artifact.classificationSummary;
+}
+export function selectContextCapsuleArtifactReferenceSummary(artifact) {
+    return artifact.artifactReferenceSummary;
+}
+export function selectContextCapsulePruning(artifact) {
+    return artifact.pruning;
+}
+export function selectContextCapsuleConflicts(artifact) {
+    return artifact.conflicts;
+}
+export function selectContextCapsuleModeEffects(artifact) {
+    return artifact.modeEffects;
+}
+export function selectContextCapsuleSourceControl(artifact) {
+    return artifact.sourceControl;
+}
+export function selectContextCapsuleDeferredRequestFields(artifact) {
+    return artifact.deferredRequestFields;
+}
+export function selectContextCapsuleRoleContext(artifact) {
+    return artifact.roleContext;
+}
+export function selectContextCapsuleEvidenceGroups(artifact) {
+    return artifact.evidenceGroups;
+}
+export function selectContextCapsuleSelectedOwners(artifact) {
+    return artifact.selectedOwners;
+}
+export function selectContextCapsuleSelectedContracts(artifact) {
+    return artifact.selectedContracts;
+}
+export function selectContextCapsuleSelectedTests(artifact) {
+    return artifact.selectedTests;
+}
+export function selectContextCapsuleTestInfrastructure(artifact) {
+    return artifact.testInfrastructure;
+}
+export function selectContextCapsuleUnresolvedItems(artifact) {
+    return artifact.unresolvedItems;
+}
+export function selectContextCapsuleGroupTruncation(artifact) {
+    return artifact.groupTruncation;
+}
+export function selectContextCapsuleResponsibilityMappings(artifact) {
+    return artifact.responsibilityMappings;
+}
+export function selectContextCapsuleRoleAdequacy(artifact) {
+    return artifact.roleAdequacy;
+}
+export function selectContextCapsuleFreshness(artifact) {
+    return artifact.freshness;
+}
+export function selectContextCapsuleBudget(artifact) {
+    return artifact.budget;
+}
+export function selectContextCapsuleTruncation(artifact) {
+    return artifact.truncation;
+}
+export function selectContextCapsuleFullFileFallback(artifact) {
+    return artifact.fullFileFallback;
+}
+export function selectContextCapsuleProvenance(artifact) {
+    return artifact.provenance;
+}

package/dist/src/evaluation/stageContextSelectors/index.js

@@ -0,0 +1,4 @@
+export * from "./contextCapsuleSelectors.js";
+export * from "./retrievalAuditRecordSelectors.js";
+export * from "./workflowInstructionPacketSelectors.js";
+export * from "./contextArtifactConsistency.js";

package/dist/src/evaluation/stageContextSelectors/retrievalAuditRecordSelectors.js

@@ -0,0 +1,54 @@
+export function selectRetrievalAuditRecordSchemaVersion(artifact) {
+    return artifact.schemaVersion;
+}
+export function selectRetrievalAuditRecordGeneratedAt(artifact) {
+    return artifact.generatedAt;
+}
+export function selectRetrievalAuditRecordTool(artifact) {
+    return artifact.tool;
+}
+export function selectRetrievalAuditRecordRequest(artifact) {
+    return artifact.request;
+}
+export function selectRetrievalAuditRecordIndex(artifact) {
+    return artifact.index;
+}
+export function selectRetrievalAuditRecordSteps(artifact) {
+    return artifact.steps;
+}
+export function selectRetrievalAuditRecordFallbacks(artifact) {
+    return artifact.fallbacks;
+}
+export function selectRetrievalAuditRecordFullFileReadRecommendations(artifact) {
+    return artifact.fullFileReadRecommendations;
+}
+export function selectRetrievalAuditRecordWarnings(artifact) {
+    return artifact.warnings;
+}
+export function selectRetrievalAuditRecordContextAdequacy(artifact) {
+    return artifact.contextAdequacy;
+}
+export function selectRetrievalAuditRecordRoleContext(artifact) {
+    return artifact.roleContext;
+}
+export function selectRetrievalAuditRecordResponsibilityMappings(artifact) {
+    return artifact.responsibilityMappings;
+}
+export function selectRetrievalAuditRecordRoleAdequacy(artifact) {
+    return artifact.roleAdequacy;
+}
+export function selectRetrievalAuditRecordFreshness(artifact) {
+    return artifact.freshness;
+}
+export function selectRetrievalAuditRecordBudget(artifact) {
+    return artifact.budget;
+}
+export function selectRetrievalAuditRecordTruncation(artifact) {
+    return artifact.truncation;
+}
+export function selectRetrievalAuditRecordFullFileFallback(artifact) {
+    return artifact.fullFileFallback;
+}
+export function selectRetrievalAuditRecordProvenance(artifact) {
+    return artifact.provenance;
+}

package/dist/src/evaluation/stageContextSelectors/workflowInstructionPacketSelectors.js

@@ -0,0 +1,51 @@
+export function selectWorkflowInstructionPacketSchemaVersion(artifact) {
+    return artifact.schemaVersion;
+}
+export function selectWorkflowInstructionPacketCatalogSchemaVersion(artifact) {
+    return artifact.catalogSchemaVersion;
+}
+export function selectWorkflowInstructionPacketCatalogVersion(artifact) {
+    return artifact.catalogVersion;
+}
+export function selectWorkflowInstructionPacketWorkflowId(artifact) {
+    return artifact.workflowId;
+}
+export function selectWorkflowInstructionPacketStageId(artifact) {
+    return artifact.stageId;
+}
+export function selectWorkflowInstructionPacketPrimaryEntry(artifact) {
+    return artifact.primaryEntry;
+}
+export function selectWorkflowInstructionPacketResolvedCommands(artifact) {
+    return artifact.resolvedCommands;
+}
+export function selectWorkflowInstructionPacketResolvedRules(artifact) {
+    return artifact.resolvedRules;
+}
+export function selectWorkflowInstructionPacketReportContract(artifact) {
+    return artifact.reportContract;
+}
+export function selectWorkflowInstructionPacketValidationRequirements(artifact) {
+    return artifact.validationRequirements;
+}
+export function selectWorkflowInstructionPacketStopConditions(artifact) {
+    return artifact.stopConditions;
+}
+export function selectWorkflowInstructionPacketResolutionProvenance(artifact) {
+    return artifact.resolutionProvenance;
+}
+export function selectWorkflowInstructionPacketBudget(artifact) {
+    return artifact.budget;
+}
+export function selectWorkflowInstructionPacketTruncation(artifact) {
+    return artifact.truncation;
+}
+export function selectWorkflowInstructionPacketAdequacy(artifact) {
+    return artifact.adequacy;
+}
+export function selectWorkflowInstructionPacketUnresolvedReferences(artifact) {
+    return artifact.unresolvedReferences;
+}
+export function selectWorkflowInstructionPacketWarnings(artifact) {
+    return artifact.warnings;
+}

package/dist/src/evaluation/targetImmutability/captureTargetSnapshot.js

@@ -0,0 +1,208 @@
+import { execFile } from "node:child_process";
+import { createHash } from "node:crypto";
+import { lstat, readFile, readlink } from "node:fs/promises";
+import path from "node:path";
+import { promisify } from "node:util";
+const execFileAsync = promisify(execFile);
+function sha256Hex(data) {
+    return createHash("sha256").update(data).digest("hex");
+}
+function stripTrailingLineTerminator(text) {
+    return text.replace(/\r?\n$/, "");
+}
+function splitLines(text) {
+    const stripped = stripTrailingLineTerminator(text);
+    return stripped.length > 0 ? stripped.split(/\r?\n/) : [];
+}
+function isInsideRoot(resolvedRoot, candidate) {
+    const relative = path.relative(resolvedRoot, candidate);
+    return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
+}
+async function snapshotPathEntry(resolvedPath) {
+    let stats;
+    try {
+        stats = await lstat(resolvedPath);
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === "ENOENT") {
+            return { state: "missing", sha256: null, symbolicLinkTarget: null };
+        }
+        throw error;
+    }
+    if (stats.isSymbolicLink()) {
+        const target = await readlink(resolvedPath);
+        return { state: "symbolic-link", sha256: null, symbolicLinkTarget: target };
+    }
+    if (stats.isDirectory()) {
+        return { state: "directory", sha256: null, symbolicLinkTarget: null };
+    }
+    if (stats.isFile()) {
+        const contents = await readFile(resolvedPath);
+        return { state: "file", sha256: sha256Hex(contents), symbolicLinkTarget: null };
+    }
+    return { state: "other", sha256: null, symbolicLinkTarget: null };
+}
+async function runGit(resolvedRoot, args) {
+    try {
+        const { stdout } = await execFileAsync("git", ["-C", resolvedRoot, ...args], {
+            encoding: "utf8",
+            maxBuffer: 1024 * 1024 * 64
+        });
+        return { ok: true, stdout };
+    }
+    catch (error) {
+        const err = error;
+        if (err.code === "ENOENT") {
+            return { ok: false, unavailable: true, message: "git executable was not found." };
+        }
+        return { ok: false, unavailable: false, message: error.message };
+    }
+}
+async function runRequiredGit(resolvedRoot, args, targetRootPath) {
+    const result = await runGit(resolvedRoot, args);
+    if (result.ok)
+        return result;
+    const code = result.unavailable ? "GIT_COMMAND_UNAVAILABLE" : "GIT_COMMAND_FAILED";
+    const message = result.unavailable
+        ? "The git executable is not available."
+        : `git ${args.join(" ")} failed: ${result.message}`;
+    return { ok: false, code, targetRootPath, message };
+}
+export async function captureTargetSnapshot(config) {
+    const resolvedTargetRootPath = path.resolve(config.targetRootPath);
+    let rootStats;
+    try {
+        rootStats = await lstat(resolvedTargetRootPath);
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === "ENOENT") {
+            return {
+                ok: false,
+                code: "TARGET_ROOT_NOT_FOUND",
+                targetRootPath: config.targetRootPath,
+                message: `Target root was not found at "${resolvedTargetRootPath}".`
+            };
+        }
+        return {
+            ok: false,
+            code: "TARGET_ROOT_UNREADABLE",
+            targetRootPath: config.targetRootPath,
+            message: `Target root at "${resolvedTargetRootPath}" could not be read: ${error.message}`
+        };
+    }
+    if (!rootStats.isDirectory()) {
+        return {
+            ok: false,
+            code: "TARGET_ROOT_NOT_DIRECTORY",
+            targetRootPath: config.targetRootPath,
+            message: `Target root at "${resolvedTargetRootPath}" is not a directory.`
+        };
+    }
+    const configuredFiles = [];
+    for (const relativePath of config.relativeFilePaths) {
+        const resolvedPath = path.resolve(resolvedTargetRootPath, relativePath);
+        if (!isInsideRoot(resolvedTargetRootPath, resolvedPath)) {
+            return {
+                ok: false,
+                code: "CONFIGURED_FILE_READ_FAILED",
+                targetRootPath: config.targetRootPath,
+                message: `Configured file "${relativePath}" resolves outside the target root.`,
+                fieldPath: relativePath
+            };
+        }
+        try {
+            const entry = await snapshotPathEntry(resolvedPath);
+            configuredFiles.push({
+                relativePath,
+                resolvedPath,
+                state: entry.state,
+                sha256: entry.sha256,
+                symbolicLinkTarget: entry.symbolicLinkTarget
+            });
+        }
+        catch (error) {
+            return {
+                ok: false,
+                code: "CONFIGURED_FILE_READ_FAILED",
+                targetRootPath: config.targetRootPath,
+                message: `Configured file "${relativePath}" could not be read: ${error.message}`,
+                fieldPath: relativePath
+            };
+        }
+    }
+    const isRepoOutcome = await runGit(resolvedTargetRootPath, ["rev-parse", "--is-inside-work-tree"]);
+    if (!isRepoOutcome.ok) {
+        if (isRepoOutcome.unavailable) {
+            return {
+                ok: false,
+                code: "GIT_COMMAND_UNAVAILABLE",
+                targetRootPath: config.targetRootPath,
+                message: "The git executable is not available."
+            };
+        }
+        const git = {
+            availability: "not-repository",
+            branch: null,
+            head: null,
+            statusEntries: [],
+            worktreeDiffSha256: null,
+            stagedDiffSha256: null,
+            untrackedFiles: []
+        };
+        return {
+            ok: true,
+            snapshot: { targetRootPath: config.targetRootPath, resolvedTargetRootPath, configuredFiles, git }
+        };
+    }
+    const branchOutcome = await runRequiredGit(resolvedTargetRootPath, ["branch", "--show-current"], config.targetRootPath);
+    if (!branchOutcome.ok)
+        return branchOutcome;
+    const branch = stripTrailingLineTerminator(branchOutcome.stdout);
+    const headOutcome = await runRequiredGit(resolvedTargetRootPath, ["rev-parse", "HEAD"], config.targetRootPath);
+    if (!headOutcome.ok)
+        return headOutcome;
+    const head = stripTrailingLineTerminator(headOutcome.stdout);
+    const statusOutcome = await runRequiredGit(resolvedTargetRootPath, ["status", "--porcelain=v1", "--untracked-files=all"], config.targetRootPath);
+    if (!statusOutcome.ok)
+        return statusOutcome;
+    const statusEntries = splitLines(statusOutcome.stdout);
+    const worktreeDiffOutcome = await runRequiredGit(resolvedTargetRootPath, ["diff", "--binary", "--no-ext-diff"], config.targetRootPath);
+    if (!worktreeDiffOutcome.ok)
+        return worktreeDiffOutcome;
+    const worktreeDiffSha256 = sha256Hex(Buffer.from(worktreeDiffOutcome.stdout, "utf8"));
+    const stagedDiffOutcome = await runRequiredGit(resolvedTargetRootPath, ["diff", "--cached", "--binary", "--no-ext-diff"], config.targetRootPath);
+    if (!stagedDiffOutcome.ok)
+        return stagedDiffOutcome;
+    const stagedDiffSha256 = sha256Hex(Buffer.from(stagedDiffOutcome.stdout, "utf8"));
+    const untrackedOutcome = await runRequiredGit(resolvedTargetRootPath, ["ls-files", "--others", "--exclude-standard"], config.targetRootPath);
+    if (!untrackedOutcome.ok)
+        return untrackedOutcome;
+    const untrackedPaths = splitLines(untrackedOutcome.stdout);
+    const untrackedFiles = [];
+    for (const untrackedRelativePath of untrackedPaths) {
+        const resolvedPath = path.resolve(resolvedTargetRootPath, untrackedRelativePath);
+        const entry = await snapshotPathEntry(resolvedPath);
+        const state = entry.state === "directory" ? "other" : entry.state;
+        untrackedFiles.push({
+            path: untrackedRelativePath,
+            state,
+            sha256: entry.sha256,
+            symbolicLinkTarget: entry.symbolicLinkTarget
+        });
+    }
+    const git = {
+        availability: "available",
+        branch,
+        head,
+        statusEntries,
+        worktreeDiffSha256,
+        stagedDiffSha256,
+        untrackedFiles
+    };
+    return {
+        ok: true,
+        snapshot: { targetRootPath: config.targetRootPath, resolvedTargetRootPath, configuredFiles, git }
+    };
+}

package/dist/src/evaluation/targetImmutability/compareTargetSnapshots.js

@@ -0,0 +1,56 @@
+import { isDeepStrictEqual } from "node:util";
+function mutation(id, kind, fieldPath, before, after) {
+    return { id, kind, fieldPath, before, after };
+}
+export function compareTargetSnapshots(before, after) {
+    const mutations = [];
+    if (before.git.availability !== after.git.availability) {
+        mutations.push(mutation("git.availability", "git-availability", "git.availability", before.git.availability, after.git.availability));
+    }
+    if (before.git.branch !== after.git.branch) {
+        mutations.push(mutation("git.branch", "git-branch", "git.branch", before.git.branch, after.git.branch));
+    }
+    if (before.git.head !== after.git.head) {
+        mutations.push(mutation("git.head", "git-head", "git.head", before.git.head, after.git.head));
+    }
+    if (!isDeepStrictEqual(before.git.statusEntries, after.git.statusEntries)) {
+        mutations.push(mutation("git.status", "git-status", "git.statusEntries", before.git.statusEntries, after.git.statusEntries));
+    }
+    if (before.git.worktreeDiffSha256 !== after.git.worktreeDiffSha256) {
+        mutations.push(mutation("git.worktree-diff", "git-worktree-diff", "git.worktreeDiffSha256", before.git.worktreeDiffSha256, after.git.worktreeDiffSha256));
+    }
+    if (before.git.stagedDiffSha256 !== after.git.stagedDiffSha256) {
+        mutations.push(mutation("git.staged-diff", "git-staged-diff", "git.stagedDiffSha256", before.git.stagedDiffSha256, after.git.stagedDiffSha256));
+    }
+    const afterUntrackedByPath = new Map(after.git.untrackedFiles.map((entry) => [entry.path, entry]));
+    const beforeUntrackedPaths = new Set(before.git.untrackedFiles.map((entry) => entry.path));
+    for (const beforeEntry of before.git.untrackedFiles) {
+        const afterEntry = afterUntrackedByPath.get(beforeEntry.path);
+        if (afterEntry === undefined) {
+            mutations.push(mutation(`git.untracked:${beforeEntry.path}`, "git-untracked-file", `git.untrackedFiles.${beforeEntry.path}`, beforeEntry, null));
+        }
+        else if (!isDeepStrictEqual(beforeEntry, afterEntry)) {
+            mutations.push(mutation(`git.untracked:${beforeEntry.path}`, "git-untracked-file", `git.untrackedFiles.${beforeEntry.path}`, beforeEntry, afterEntry));
+        }
+    }
+    for (const afterEntry of after.git.untrackedFiles) {
+        if (!beforeUntrackedPaths.has(afterEntry.path)) {
+            mutations.push(mutation(`git.untracked:${afterEntry.path}`, "git-untracked-file", `git.untrackedFiles.${afterEntry.path}`, null, afterEntry));
+        }
+    }
+    const afterConfiguredByPath = new Map(after.configuredFiles.map((entry) => [entry.relativePath, entry]));
+    for (const beforeEntry of before.configuredFiles) {
+        const afterEntry = afterConfiguredByPath.get(beforeEntry.relativePath);
+        if (afterEntry === undefined || !isDeepStrictEqual(beforeEntry, afterEntry)) {
+            mutations.push(mutation(`file:${beforeEntry.relativePath}`, "configured-file", `configuredFiles.${beforeEntry.relativePath}`, beforeEntry, (afterEntry ?? null)));
+        }
+    }
+    return {
+        status: mutations.length > 0 ? "mutated" : "unchanged",
+        targetRootPath: before.targetRootPath,
+        resolvedTargetRootPath: before.resolvedTargetRootPath,
+        preExistingGitStatusEntryCount: before.git.statusEntries.length,
+        newMutationCount: mutations.length,
+        mutations
+    };
+}

package/dist/src/evaluation/targetImmutability/index.js

@@ -0,0 +1,3 @@
+export { validateTargetImmutabilityConfig } from "./validateTargetImmutabilityConfig.js";
+export { captureTargetSnapshot } from "./captureTargetSnapshot.js";
+export { compareTargetSnapshots } from "./compareTargetSnapshots.js";

package/dist/src/evaluation/targetImmutability/types.js

@@ -0,0 +1 @@
+export {};

package/dist/src/evaluation/targetImmutability/validateTargetImmutabilityConfig.js

@@ -0,0 +1,130 @@
+const ALLOWED_KEYS = ["targetRootPath", "relativeFilePaths"];
+const MAX_RELATIVE_FILES = 100;
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isAbsolutePathLike(value) {
+    if (value.startsWith("/") || value.startsWith("\\"))
+        return true;
+    if (/^[A-Za-z]:[\\/]/.test(value))
+        return true;
+    return false;
+}
+function hasTraversalSegment(value) {
+    return value.split(/[\\/]/).includes("..");
+}
+export function validateTargetImmutabilityConfig(value) {
+    if (!isPlainObject(value)) {
+        return {
+            ok: false,
+            issues: [{ code: "NON_OBJECT_CONFIG", fieldPath: "", message: "Target immutability config must be an object." }]
+        };
+    }
+    const root = value;
+    const issues = [];
+    for (const key of Object.keys(root)) {
+        if (!ALLOWED_KEYS.includes(key)) {
+            issues.push({ code: "UNKNOWN_CONFIG_FIELD", fieldPath: key, message: `"${key}" is not a recognized field.` });
+        }
+    }
+    if (root.targetRootPath === undefined) {
+        issues.push({ code: "MISSING_REQUIRED_FIELD", fieldPath: "targetRootPath", message: "targetRootPath is required." });
+    }
+    if (root.relativeFilePaths === undefined) {
+        issues.push({ code: "MISSING_REQUIRED_FIELD", fieldPath: "relativeFilePaths", message: "relativeFilePaths is required." });
+    }
+    const targetRootPathIsString = root.targetRootPath !== undefined && typeof root.targetRootPath === "string";
+    if (root.targetRootPath !== undefined && !targetRootPathIsString) {
+        issues.push({ code: "INVALID_FIELD_TYPE", fieldPath: "targetRootPath", message: "targetRootPath must be a string." });
+    }
+    const relativeFilePathsIsArray = root.relativeFilePaths !== undefined && Array.isArray(root.relativeFilePaths);
+    if (root.relativeFilePaths !== undefined && !relativeFilePathsIsArray) {
+        issues.push({ code: "INVALID_FIELD_TYPE", fieldPath: "relativeFilePaths", message: "relativeFilePaths must be an array." });
+    }
+    if (targetRootPathIsString && root.targetRootPath.trim().length === 0) {
+        issues.push({ code: "EMPTY_TARGET_ROOT_PATH", fieldPath: "targetRootPath", message: "targetRootPath must be a nonempty string." });
+    }
+    let pathsArray = [];
+    if (relativeFilePathsIsArray) {
+        pathsArray = root.relativeFilePaths;
+        if (pathsArray.length === 0) {
+            issues.push({
+                code: "EMPTY_RELATIVE_FILE_SET",
+                fieldPath: "relativeFilePaths",
+                message: "relativeFilePaths must contain at least one entry."
+            });
+        }
+        else if (pathsArray.length > MAX_RELATIVE_FILES) {
+            issues.push({
+                code: "TOO_MANY_RELATIVE_FILES",
+                fieldPath: "relativeFilePaths",
+                message: `relativeFilePaths must contain at most ${MAX_RELATIVE_FILES} entries.`
+            });
+        }
+    }
+    const validStringPaths = [];
+    if (relativeFilePathsIsArray) {
+        pathsArray.forEach((entry, index) => {
+            if (typeof entry !== "string") {
+                issues.push({
+                    code: "INVALID_FIELD_TYPE",
+                    fieldPath: `relativeFilePaths[${index}]`,
+                    message: `relativeFilePaths[${index}] must be a string.`
+                });
+                validStringPaths.push(null);
+            }
+            else if (entry.trim().length === 0) {
+                issues.push({
+                    code: "EMPTY_RELATIVE_FILE_PATH",
+                    fieldPath: `relativeFilePaths[${index}]`,
+                    message: `relativeFilePaths[${index}] must be a nonempty string.`
+                });
+                validStringPaths.push(null);
+            }
+            else {
+                validStringPaths.push(entry);
+            }
+        });
+    }
+    if (relativeFilePathsIsArray) {
+        validStringPaths.forEach((entry, index) => {
+            if (entry !== null && isAbsolutePathLike(entry)) {
+                issues.push({
+                    code: "ABSOLUTE_RELATIVE_FILE_PATH",
+                    fieldPath: `relativeFilePaths[${index}]`,
+                    message: `relativeFilePaths[${index}] must be a relative path.`
+                });
+            }
+        });
+    }
+    if (relativeFilePathsIsArray) {
+        validStringPaths.forEach((entry, index) => {
+            if (entry !== null && hasTraversalSegment(entry)) {
+                issues.push({
+                    code: "RELATIVE_FILE_PATH_TRAVERSAL",
+                    fieldPath: `relativeFilePaths[${index}]`,
+                    message: `relativeFilePaths[${index}] must not contain a ".." path segment.`
+                });
+            }
+        });
+    }
+    if (relativeFilePathsIsArray) {
+        const seen = new Set();
+        validStringPaths.forEach((entry, index) => {
+            if (entry === null)
+                return;
+            if (seen.has(entry)) {
+                issues.push({
+                    code: "DUPLICATE_RELATIVE_FILE_PATH",
+                    fieldPath: `relativeFilePaths[${index}]`,
+                    message: `relativeFilePaths[${index}] duplicates an earlier entry.`
+                });
+            }
+            seen.add(entry);
+        });
+    }
+    if (issues.length > 0) {
+        return { ok: false, issues };
+    }
+    return { ok: true, config: value };
+}

package/dist/src/evaluation/upstreamArtifacts/artifactReadTypes.js

@@ -0,0 +1 @@
+export {};

package/dist/src/evaluation/upstreamArtifacts/index.js

@@ -0,0 +1,3 @@
+export { readMyDevKitContextCapsuleV1 } from "./readMyDevKitContextCapsuleV1.js";
+export { readMyDevKitRetrievalAuditRecordV1 } from "./readMyDevKitRetrievalAuditRecordV1.js";
+export { readOrchestratorWorkflowInstructionPacketV1 } from "./readOrchestratorWorkflowInstructionPacketV1.js";

package/dist/src/evaluation/upstreamArtifacts/jsonTypes.js

@@ -0,0 +1 @@
+export {};

package/dist/src/evaluation/upstreamArtifacts/myDevKitClassificationTypesV1.js

@@ -0,0 +1 @@
+export {};

package/dist/src/evaluation/upstreamArtifacts/myDevKitContextArtifactsV1.js

@@ -0,0 +1 @@
+export {};

package/dist/src/evaluation/upstreamArtifacts/myDevKitSemanticTypesV1.js

@@ -0,0 +1 @@
+export {};

package/dist/src/evaluation/upstreamArtifacts/orchestratorWorkflowInstructionPacketV1.js

@@ -0,0 +1 @@
+export {};