@deftai/directive-core 0.55.0

package/dist/slice/existing.js

@@ -0,0 +1,344 @@
+import { call as scmCall } from "../scm/call.js";
+import { pyRepr } from "../scm/py-format.js";
+import { DEFAULT_ACTOR, DEFAULT_EXPECTED_CLOSE_SIGNAL, DEFAULT_ROLE, WAVE_FLAG_RE, } from "./constants.js";
+import { IssueValidationError, SliceRecordError } from "./errors.js";
+import { pythonJsonPretty } from "./json.js";
+import { appendLock, withAppendLock } from "./lock.js";
+import { formatMissingRepoError, formatMissingRootError, resolveRootAndRepo, } from "./project-context.js";
+import { newSliceId, nowIso, readAll, slicesPath, writeSliceUnlocked } from "./record.js";
+export function parseChildrenCsv(value) {
+    if (value.length === 0) {
+        throw new Error("expected at least one child issue number");
+    }
+    const out = [];
+    const seen = new Set();
+    for (const part of value.split(",")) {
+        const token = part.trim();
+        if (token.length === 0) {
+            continue;
+        }
+        const n = Number.parseInt(token, 10);
+        if (Number.isNaN(n)) {
+            throw new Error(`invalid child issue number '${token}' (must be a positive int)`);
+        }
+        if (n < 1) {
+            throw new Error(`invalid child issue number ${n} (must be a positive int)`);
+        }
+        if (seen.has(n)) {
+            throw new Error(`duplicate child issue number ${n}`);
+        }
+        seen.add(n);
+        out.push(n);
+    }
+    if (out.length === 0) {
+        throw new Error("expected at least one child issue number");
+    }
+    return out;
+}
+export function consumeWaveFlags(rawArgs) {
+    const waveMap = new Map();
+    const remaining = [];
+    let i = 0;
+    while (i < rawArgs.length) {
+        const token = rawArgs[i] ?? "";
+        const match = WAVE_FLAG_RE.exec(token);
+        if (!match) {
+            remaining.push(token);
+            i += 1;
+            continue;
+        }
+        const waveN = Number.parseInt(match[1] ?? "0", 10);
+        if (waveN < 1) {
+            throw new Error(`invalid wave number in '${token}' (must be >= 1)`);
+        }
+        let value;
+        if (match[2] !== undefined) {
+            value = match[2];
+            i += 1;
+        }
+        else if (i + 1 < rawArgs.length) {
+            value = rawArgs[i + 1];
+            i += 2;
+        }
+        else {
+            throw new Error(`missing value for '${token}'`);
+        }
+        const children = parseChildrenCsv(value ?? "");
+        const bucket = waveMap.get(waveN) ?? [];
+        for (const n of children) {
+            if (!bucket.includes(n)) {
+                bucket.push(n);
+            }
+        }
+        waveMap.set(waveN, bucket);
+    }
+    const placement = new Map();
+    for (const [waveN, members] of waveMap) {
+        for (const n of members) {
+            const prior = placement.get(n);
+            if (prior !== undefined && prior !== waveN) {
+                throw new Error(`child ${n} appears in both --wave-${prior} and --wave-${waveN}; each child belongs to one wave`);
+            }
+            placement.set(n, waveN);
+        }
+    }
+    return { waveMap, remaining };
+}
+export function repoSlugToUrl(repo, n) {
+    return `https://github.com/${repo}/issues/${n}`;
+}
+export function buildChildren(children, waveMap, repo) {
+    const waveFor = new Map();
+    for (const [waveN, members] of waveMap) {
+        for (const n of members) {
+            waveFor.set(n, waveN);
+        }
+    }
+    return children.map((n) => ({
+        n,
+        url: repoSlugToUrl(repo, n),
+        wave: waveFor.get(n) ?? 1,
+        role: DEFAULT_ROLE,
+    }));
+}
+export function childrenSet(record) {
+    const children = record.children;
+    if (!Array.isArray(children)) {
+        return new Set();
+    }
+    const out = new Set();
+    for (const child of children) {
+        if (child !== null && typeof child === "object" && !Array.isArray(child)) {
+            const n = child.n;
+            if (typeof n === "number" && Number.isInteger(n)) {
+                out.add(n);
+            }
+        }
+    }
+    return out;
+}
+export function findDuplicate(umbrella, childrenNumbers, slicesLogPath) {
+    const target = new Set(childrenNumbers);
+    for (const record of readAll({ path: slicesLogPath })) {
+        if (record.umbrella !== umbrella) {
+            continue;
+        }
+        const childSet = childrenSet(record);
+        if (childSet.size === target.size && [...target].every((n) => childSet.has(n))) {
+            return record;
+        }
+    }
+    return null;
+}
+export function validateIssueExists(n, repo, deps = {}) {
+    const scm = deps.scm ?? scmCall;
+    let proc;
+    try {
+        proc = scm("github-issue", "issue", ["view", String(n), "--repo", repo, "--json", "number,url"], {
+            check: false,
+            captureOutput: true,
+            text: true,
+            timeout: 30,
+        });
+    }
+    catch {
+        throw new IssueValidationError(`timed out validating issue #${n} in ${repo}`);
+    }
+    if (proc.returncode !== 0) {
+        const stderr = proc.stderr.trim() || "(no stderr)";
+        throw new IssueValidationError(`issue #${n} in ${repo} not found / inaccessible: ${stderr}`);
+    }
+}
+export function summariseWaves(waveMap, totalChildren) {
+    if (waveMap.size === 0) {
+        return `${totalChildren} in wave 1 (default)`;
+    }
+    const placedByWave = new Map();
+    for (const [waveN, members] of waveMap) {
+        placedByWave.set(waveN, members.length);
+    }
+    let placedTotal = 0;
+    for (const count of placedByWave.values()) {
+        placedTotal += count;
+    }
+    const unassigned = totalChildren - placedTotal;
+    if (unassigned > 0) {
+        placedByWave.set(1, (placedByWave.get(1) ?? 0) + unassigned);
+    }
+    const parts = [...placedByWave.keys()]
+        .sort((a, b) => a - b)
+        .map((waveN) => `wave-${waveN}=${placedByWave.get(waveN)}`);
+    return `${parts.length} wave(s): ${parts.join(", ")}`;
+}
+function duplicateMessage(umbrella, duplicate) {
+    return (`slice:record-existing: umbrella #${umbrella} already has a matching record (slice_id=${String(duplicate.slice_id)}, ` +
+        `actor=${String(duplicate.actor)}). Re-run with --force to write a second record.`);
+}
+export function runRecordExisting(args, waveMap, deps = {}) {
+    const resolved = resolveRootAndRepo(args.projectRoot, args.repo, true);
+    if (resolved.exitCode !== 0) {
+        const message = resolved.repo === null && resolved.projectRoot !== "."
+            ? formatMissingRepoError()
+            : formatMissingRootError();
+        return { exitCode: resolved.exitCode, stdout: "", stderr: `${message}\n` };
+    }
+    const repo = resolved.repo;
+    if (repo === null) {
+        throw new Error("repo is None despite require_repo=True; this is a bug in resolveRootAndRepo");
+    }
+    let children;
+    try {
+        children = parseChildrenCsv(args.children);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return { exitCode: 2, stdout: "", stderr: `error: ${msg}\n` };
+    }
+    const declared = new Set(children);
+    for (const [waveN, members] of waveMap) {
+        for (const n of members) {
+            if (!declared.has(n)) {
+                return {
+                    exitCode: 2,
+                    stdout: "",
+                    stderr: `error: --wave-${waveN} references child #${n} not present in --children\n`,
+                };
+            }
+        }
+    }
+    if (declared.has(args.umbrella)) {
+        return {
+            exitCode: 2,
+            stdout: "",
+            stderr: `error: umbrella #${args.umbrella} cannot also appear in --children\n`,
+        };
+    }
+    if (!args.skipValidation) {
+        try {
+            validateIssueExists(args.umbrella, repo, deps);
+            for (const n of children) {
+                validateIssueExists(n, repo, deps);
+            }
+        }
+        catch (err) {
+            if (err instanceof IssueValidationError) {
+                return { exitCode: 1, stdout: "", stderr: `error: ${err.message}\n` };
+            }
+            if (err instanceof Error && err.message.includes("not yet supported")) {
+                return { exitCode: 1, stdout: "", stderr: `error: ${err.message}\n` };
+            }
+            throw err;
+        }
+    }
+    const logPath = slicesPath(resolved.projectRoot);
+    const findDup = deps.findDuplicateFn ?? findDuplicate;
+    const duplicate = findDup(args.umbrella, children, logPath);
+    if (duplicate !== null && !args.force) {
+        return { exitCode: 0, stdout: "", stderr: `${duplicateMessage(args.umbrella, duplicate)}\n` };
+    }
+    const childDicts = buildChildren(children, waveMap, repo);
+    const clock = deps.nowIso ?? nowIso;
+    if (args.dryRun) {
+        const proposed = {
+            slice_id: "<dry-run>",
+            umbrella: args.umbrella,
+            umbrella_url: repoSlugToUrl(repo, args.umbrella),
+            sliced_at: args.slicedAt ?? clock(),
+            actor: args.actor,
+            children: childDicts,
+            expected_close_signal: args.expectedCloseSignal,
+        };
+        if (args.notes !== null) {
+            proposed.notes = args.notes;
+        }
+        const waveSummary = summariseWaves(waveMap, children.length);
+        return {
+            exitCode: 0,
+            stdout: `${pythonJsonPretty(proposed)}\n`,
+            stderr: `DRY-RUN: would write slices.jsonl entry for umbrella ` +
+                `#${args.umbrella} (${children.length} children, ${waveSummary}).\n`,
+        };
+    }
+    const record = {
+        slice_id: (deps.newSliceId ?? newSliceId)(),
+        umbrella: args.umbrella,
+        umbrella_url: repoSlugToUrl(repo, args.umbrella),
+        sliced_at: args.slicedAt ?? clock(),
+        actor: args.actor,
+        children: childDicts,
+        expected_close_signal: args.expectedCloseSignal,
+    };
+    if (args.notes !== null) {
+        record.notes = args.notes;
+    }
+    try {
+        const lock = deps.withLock ?? withAppendLock;
+        const outcome = lock(logPath, () => {
+            const authoritativeDup = findDup(args.umbrella, children, logPath);
+            if (authoritativeDup !== null && !args.force) {
+                return { kind: "duplicate", duplicate: authoritativeDup };
+            }
+            const id = writeSliceUnlocked(record, { path: logPath });
+            return { kind: "written", sliceId: id };
+        });
+        if (outcome.kind === "duplicate") {
+            return {
+                exitCode: 0,
+                stdout: "",
+                stderr: `${duplicateMessage(args.umbrella, outcome.duplicate)}\n`,
+            };
+        }
+        const waveSummary = summariseWaves(waveMap, children.length);
+        return {
+            exitCode: 0,
+            stdout: `Wrote vbrief/.eval/slices.jsonl entry for umbrella ` +
+                `#${args.umbrella} (${children.length} children, ${waveSummary}). ` +
+                `slice_id=${outcome.sliceId}\n`,
+            stderr: "",
+        };
+    }
+    catch (err) {
+        if (err instanceof SliceRecordError) {
+            return { exitCode: 1, stdout: "", stderr: `error: invalid record -- ${err.message}\n` };
+        }
+        throw err;
+    }
+}
+export function runList(args) {
+    const resolved = resolveRootAndRepo(args.projectRoot, null, false);
+    if (resolved.exitCode !== 0) {
+        return { exitCode: 2, stdout: "", stderr: `${formatMissingRootError()}\n` };
+    }
+    const records = readAll({ path: slicesPath(resolved.projectRoot) });
+    if (args.asJson) {
+        return { exitCode: 0, stdout: `${pythonJsonPretty(records)}\n`, stderr: "" };
+    }
+    if (records.length === 0) {
+        return {
+            exitCode: 0,
+            stdout: "slice:list: no records found in vbrief/.eval/slices.jsonl (file absent or empty).\n",
+            stderr: "",
+        };
+    }
+    const lines = [`slice:list: ${records.length} record(s) in vbrief/.eval/slices.jsonl`];
+    for (const record of records) {
+        const umbrella = record.umbrella ?? "?";
+        const actor = record.actor ?? "?";
+        const slicedAt = record.sliced_at ?? "?";
+        const sliceId = record.slice_id ?? "?";
+        const children = record.children;
+        const childCount = Array.isArray(children) ? children.length : 0;
+        const signal = record.expected_close_signal ?? "?";
+        const notes = record.notes;
+        let line = `  - umbrella=#${String(umbrella)} children=${childCount} ` +
+            `actor=${String(actor)} sliced_at=${String(slicedAt)} ` +
+            `signal=${String(signal)} slice_id=${String(sliceId)}`;
+        if (typeof notes === "string" && notes.length > 0) {
+            line += ` notes=${pyRepr(notes)}`;
+        }
+        lines.push(line);
+    }
+    return { exitCode: 0, stdout: `${lines.join("\n")}\n`, stderr: "" };
+}
+export { appendLock, DEFAULT_ACTOR, DEFAULT_EXPECTED_CLOSE_SIGNAL };
+//# sourceMappingURL=existing.js.map

package/dist/slice/index.d.ts

@@ -0,0 +1,10 @@
+export { main, parseCli, runCli } from "./cli.js";
+export * from "./constants.js";
+export * from "./errors.js";
+export * from "./existing.js";
+export * from "./json.js";
+export * from "./lock.js";
+export * from "./project-context.js";
+export * from "./record.js";
+export * from "./validate.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/slice/index.js

@@ -0,0 +1,10 @@
+export { main, parseCli, runCli } from "./cli.js";
+export * from "./constants.js";
+export * from "./errors.js";
+export * from "./existing.js";
+export * from "./json.js";
+export * from "./lock.js";
+export * from "./project-context.js";
+export * from "./record.js";
+export * from "./validate.js";
+//# sourceMappingURL=index.js.map

package/dist/slice/json.d.ts

@@ -0,0 +1,7 @@
+/** Recursively sort object keys like Python json.dumps(..., sort_keys=True). */
+export declare function sortKeysDeep(value: unknown): unknown;
+/** JSON.dumps(..., sort_keys=True, ensure_ascii=False) with Python separators. */
+export declare function pythonJsonStringify(value: unknown): string;
+/** JSON.dumps(..., sort_keys=True, ensure_ascii=False, indent=2). */
+export declare function pythonJsonPretty(value: unknown): string;
+//# sourceMappingURL=json.d.ts.map

package/dist/slice/json.js

@@ -0,0 +1,25 @@
+import { expandPythonJsonSeparators } from "../text/redos-safe.js";
+/** Recursively sort object keys like Python json.dumps(..., sort_keys=True). */
+export function sortKeysDeep(value) {
+    if (Array.isArray(value)) {
+        return value.map((item) => sortKeysDeep(item));
+    }
+    if (value !== null && typeof value === "object") {
+        const obj = value;
+        const sorted = {};
+        for (const key of Object.keys(obj).sort()) {
+            sorted[key] = sortKeysDeep(obj[key]);
+        }
+        return sorted;
+    }
+    return value;
+}
+/** JSON.dumps(..., sort_keys=True, ensure_ascii=False) with Python separators. */
+export function pythonJsonStringify(value) {
+    return expandPythonJsonSeparators(JSON.stringify(sortKeysDeep(value)));
+}
+/** JSON.dumps(..., sort_keys=True, ensure_ascii=False, indent=2). */
+export function pythonJsonPretty(value) {
+    return JSON.stringify(sortKeysDeep(value), null, 2);
+}
+//# sourceMappingURL=json.js.map

package/dist/slice/lock.d.ts

@@ -0,0 +1,9 @@
+export interface LockDeps {
+    readonly sleepMs?: (ms: number) => void;
+    readonly now?: () => number;
+}
+/** Serialise appenders across threads AND processes (sidecar lock file). */
+export declare function withAppendLock<T>(logPath: string, fn: () => T, deps?: LockDeps): T;
+/** Public alias mirroring Python append_lock. */
+export declare const appendLock: typeof withAppendLock;
+//# sourceMappingURL=lock.d.ts.map

package/dist/slice/lock.js

@@ -0,0 +1,59 @@
+import { closeSync, existsSync, mkdirSync, openSync, unlinkSync, writeSync } from "node:fs";
+import { dirname } from "node:path";
+const threadLocked = { held: false };
+function defaultSleep(ms) {
+    const end = Date.now() + ms;
+    while (Date.now() < end) {
+        /* spin */
+    }
+}
+/** Serialise appenders across threads AND processes (sidecar lock file). */
+export function withAppendLock(logPath, fn, deps = {}) {
+    const sleepMs = deps.sleepMs ?? defaultSleep;
+    const now = deps.now ?? Date.now;
+    const lockPath = `${logPath}.lock`;
+    mkdirSync(dirname(lockPath), { recursive: true });
+    if (threadLocked.held) {
+        throw new Error("append lock is not reentrant");
+    }
+    threadLocked.held = true;
+    let fd;
+    try {
+        const deadline = now() + 30_000;
+        while (true) {
+            try {
+                fd = openSync(lockPath, "wx");
+                writeSync(fd, Buffer.from("\0"));
+                break;
+            }
+            catch (err) {
+                const code = err.code;
+                if (code !== "EEXIST") {
+                    throw err;
+                }
+                if (now() > deadline) {
+                    throw new Error(`timed out acquiring lock for ${logPath}`);
+                }
+                sleepMs(20);
+            }
+        }
+        return fn();
+    }
+    finally {
+        if (fd !== undefined) {
+            closeSync(fd);
+        }
+        threadLocked.held = false;
+        try {
+            if (existsSync(lockPath)) {
+                unlinkSync(lockPath);
+            }
+        }
+        catch {
+            /* best-effort */
+        }
+    }
+}
+/** Public alias mirroring Python append_lock. */
+export const appendLock = withAppendLock;
+//# sourceMappingURL=lock.js.map

package/dist/slice/project-context.d.ts

@@ -0,0 +1,15 @@
+/** Resolve the consumer project root using the documented precedence. */
+export declare function resolveProjectRoot(cliProjectRoot?: string | null, start?: string): string | null;
+/** Accept OWNER/NAME or a full GitHub URL, return OWNER/NAME. */
+export declare function normaliseRepoSlug(value: string): string | null;
+/** Resolve the consumer GitHub repo (OWNER/NAME). */
+export declare function resolveProjectRepo(cliRepo: string | null | undefined, projectRoot: string | null): string | null;
+export interface RootRepoResult {
+    readonly projectRoot: string;
+    readonly repo: string | null;
+    readonly exitCode: number;
+}
+export declare function resolveRootAndRepo(cliProjectRoot: string | null | undefined, cliRepo: string | null | undefined, requireRepo: boolean): RootRepoResult;
+export declare function formatMissingRootError(): string;
+export declare function formatMissingRepoError(): string;
+//# sourceMappingURL=project-context.d.ts.map

package/dist/slice/project-context.js

@@ -0,0 +1,87 @@
+import { execFileSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+import { parseGitHubRepoSlug } from "../text/redos-safe.js";
+import { ENV_PROJECT_REPO, ENV_PROJECT_ROOT, PROJECT_ROOT_SENTINELS } from "./constants.js";
+function isProjectRoot(candidate) {
+    return PROJECT_ROOT_SENTINELS.some((sentinel) => existsSync(resolve(candidate, sentinel)));
+}
+/** Resolve the consumer project root using the documented precedence. */
+export function resolveProjectRoot(cliProjectRoot, start) {
+    if (cliProjectRoot !== undefined && cliProjectRoot !== null && cliProjectRoot.length > 0) {
+        const candidate = resolve(cliProjectRoot);
+        return existsSync(candidate) ? candidate : null;
+    }
+    const envRoot = process.env[ENV_PROJECT_ROOT]?.trim() ?? "";
+    if (envRoot.length > 0) {
+        const candidate = resolve(envRoot);
+        return existsSync(candidate) ? candidate : null;
+    }
+    const cwd = resolve(start ?? process.cwd());
+    let current = cwd;
+    while (true) {
+        if (isProjectRoot(current)) {
+            return current;
+        }
+        const parent = resolve(current, "..");
+        if (parent === current) {
+            break;
+        }
+        current = parent;
+    }
+    return null;
+}
+/** Accept OWNER/NAME or a full GitHub URL, return OWNER/NAME. */
+export function normaliseRepoSlug(value) {
+    return parseGitHubRepoSlug(value);
+}
+function detectRepoFromGit(projectRoot) {
+    try {
+        const stdout = execFileSync("git", ["remote", "get-url", "origin"], {
+            cwd: projectRoot ?? undefined,
+            encoding: "utf8",
+            timeout: 10_000,
+            stdio: ["ignore", "pipe", "ignore"],
+        });
+        return normaliseRepoSlug(stdout.trim());
+    }
+    catch {
+        return null;
+    }
+}
+/** Resolve the consumer GitHub repo (OWNER/NAME). */
+export function resolveProjectRepo(cliRepo, projectRoot) {
+    if (cliRepo !== undefined && cliRepo !== null && cliRepo.length > 0) {
+        return normaliseRepoSlug(cliRepo);
+    }
+    const envRepo = process.env[ENV_PROJECT_REPO]?.trim() ?? "";
+    if (envRepo.length > 0) {
+        return normaliseRepoSlug(envRepo);
+    }
+    return detectRepoFromGit(projectRoot);
+}
+export function resolveRootAndRepo(cliProjectRoot, cliRepo, requireRepo) {
+    const projectRoot = resolveProjectRoot(cliProjectRoot ?? undefined);
+    if (projectRoot === null) {
+        return { projectRoot: ".", repo: null, exitCode: 2 };
+    }
+    if (!requireRepo) {
+        return { projectRoot, repo: null, exitCode: 0 };
+    }
+    const repo = resolveProjectRepo(cliRepo ?? undefined, projectRoot);
+    if (repo === null) {
+        return { projectRoot, repo: null, exitCode: 2 };
+    }
+    return { projectRoot, repo, exitCode: 0 };
+}
+export function formatMissingRootError() {
+    return ("error: cannot determine project root. Pass --project-root PATH, " +
+        "set $DEFT_PROJECT_ROOT, or run from inside a directory tree that " +
+        "contains vbrief/ or .git/ (#535).");
+}
+export function formatMissingRepoError() {
+    return ("error: cannot determine repo slug. Pass --repo OWNER/NAME, " +
+        "set $DEFT_PROJECT_REPO, or run inside a git checkout with an " +
+        "origin remote.");
+}
+//# sourceMappingURL=project-context.js.map

package/dist/slice/record.d.ts

@@ -0,0 +1,50 @@
+import { appendFileSync, closeSync, existsSync, fsyncSync, mkdirSync, openSync, readFileSync } from "node:fs";
+import { withAppendLock } from "./lock.js";
+export interface WriteSliceOptions {
+    readonly umbrellaUrl: string;
+    readonly actor: string;
+    readonly expectedCloseSignal?: string;
+    readonly sliceId?: string;
+    readonly slicedAt?: string;
+    readonly notes?: string;
+    readonly path?: string;
+    readonly nowIso?: () => string;
+    readonly newSliceId?: () => string;
+}
+export interface RecordModuleDeps {
+    readonly readFile?: typeof readFileSync;
+    readonly exists?: typeof existsSync;
+    readonly append?: typeof appendFileSync;
+    readonly fsync?: typeof fsyncSync;
+    readonly open?: typeof openSync;
+    readonly close?: typeof closeSync;
+    readonly mkdir?: typeof mkdirSync;
+    readonly withLock?: typeof withAppendLock;
+}
+export declare function newSliceId(): string;
+/** Return the current UTC time in canonical ISO-8601 form with Z suffix (no fractional seconds). */
+export declare function nowIso(): string;
+/** Validate + append record without acquiring the sidecar lock. */
+export declare function writeSliceUnlocked(record: Record<string, unknown>, options?: {
+    path?: string;
+    deps?: RecordModuleDeps;
+    warn?: (message: string) => void;
+}): string;
+/** Validate and atomically append a cohort record to slices.jsonl. */
+export declare function writeSlice(umbrella: number, children: Iterable<Record<string, unknown>>, options: WriteSliceOptions, deps?: RecordModuleDeps): string;
+/** Return every well-formed slice record in insertion order. */
+export declare function readAll(options?: {
+    path?: string;
+    deps?: RecordModuleDeps;
+    warn?: (message: string) => void;
+}): Record<string, unknown>[];
+export declare function findBySliceId(sliceId: string, options?: {
+    path?: string;
+    deps?: RecordModuleDeps;
+}): Record<string, unknown> | null;
+export declare function findByUmbrella(umbrella: number, options?: {
+    path?: string;
+    deps?: RecordModuleDeps;
+}): Record<string, unknown>[];
+export declare function slicesPath(projectRoot: string): string;
+//# sourceMappingURL=record.d.ts.map