peaks-loop 4.0.0-beta.6 → 4.0.0-beta.8

package/dist/src/services/slice/multi-pass-orchestrator.js

@@ -1,225 +0,0 @@
-/**
- * MultiPassOrchestrator — Phase 2 of slice-topology-multipass (W2 T9).
- *
- * Top-level orchestrator that runs the existing 6-stage algorithm
- * (`decomposeSlices`) at service-level and/or file-level granularity, then
- * stitches the passes together with `merge` to produce a v2
- * `DecompositionResultV2` with cross-pass edges.
- *
- * Granularity semantics:
- *   - 'service': Pass 1 only. Each workUnit becomes a SliceV2 with
- *                granularity='service' and parentSliceId=null.
- *   - 'file':    Pass 2 only. `decomposeSlices` is called once on the full
- *                scope (no parent subdivision). Each workUnit becomes a
- *                SliceV2 with granularity='file' and parentSliceId=null.
- *   - 'both':    Pass 1 + N Pass 2 (one per parent). Pass 2 runs for every
- *                Pass 1 slice without decider filtering.
- *   - 'auto':    Same as 'both' but Pass 2 only runs for parents where
- *                `shouldSubdivide(wu).subdivide !== false` (both `true` and
- *                `'tie-break'` qualify).
- *
- * Granularity-mapping approach (see pre-flight note in the task spec):
- *   Approach 1 — pass-through with post-hoc filter. The 6-stage algorithm
- *   (`decomposeSlices`) does NOT accept a `granularity` or `scopeFilter`
- *   option, and the pre-flight note recommends NOT extending `DecomposeOptions`
- *   (surgical change rule). We therefore:
- *     1. Pass the full `opts` (including the orchestrator-only `granularity`
- *        and `llmRunner` fields) through to `decomposeSlices`; the algorithm
- *        ignores the extra fields.
- *     2. Filter Pass 2 `result.workUnits` post-hoc so each Pass 2 result
- *        only contains files inside the parent slice's file scope.
- *
- * Cross-pass edges are produced by `merge` whenever there are ≥2 passes.
- * The merger handles both static detection (type-shares, fixture-shares,
- * import-re-export — runs UNCONDITIONALLY) and the LLM fallback path (only
- * when `opts.llmRunner` is provided). Without an llmRunner the orchestrator
- * still gets statically-detected cross-pass edges; only `llmArbitrations`
- * stays empty.
- *
- * @see ./slice-decompose-service.ts  — the 6-stage algorithm (reused as-is)
- * @see ./granularity-decider.ts      — subdivide decision
- * @see ./cross-pass-edge-merger.ts   — cross-pass edge detection
- * @see ./llm-arbitrator.ts           — LLM fallback for cross-pass edges
- * @see ./slice-topology-types.ts     — DecompositionResultV2, PassResult, etc.
- */
-import { decomposeSlices } from './slice-decompose-service.js';
-import { resetArbitratorBudget } from './llm-arbitrator.js';
-import { shouldSubdivide } from './granularity-decider.js';
-import { merge } from './cross-pass-edge-merger.js';
-/**
- * Run the multi-pass decomposition algorithm and return a v2 result.
- *
- * 1. Reset the LLM arbitrator budget for this invocation.
- * 2. Run Pass 1 (service-level) if granularity includes 'service'.
- * 3. Run Pass 2 (file-level) — for every qualifying parent in 'both'/'auto',
- *    or once on the full scope in 'file'-only mode.
- * 4. Compute cross-pass edges via `merge` whenever there are ≥2 passes
- *    (static detection runs unconditionally; LLM fallback only when an
- *    llmRunner is supplied).
- * 5. Return a `DecompositionResultV2` with `partial: false`.
- */
-export async function decompose(rid, prdMarkdown, projectRoot, opts = {}) {
-    resetArbitratorBudget();
-    const granularity = opts.granularity ?? 'both';
-    const wantService = granularity === 'service' || granularity === 'both' || granularity === 'auto';
-    const wantFile = granularity === 'file' || granularity === 'both' || granularity === 'auto';
-    const passes = [];
-    let codegraph = zeroCodegraph();
-    let understandAnything = zeroUnderstand();
-    let pass1WorkUnits = [];
-    if (wantService) {
-        const result1 = await decomposeSlices(rid, prdMarkdown, projectRoot, opts);
-        pass1WorkUnits = result1.workUnits;
-        passes.push({
-            passNumber: 1,
-            granularity: 'service',
-            slices: result1.workUnits.map((wu) => workUnitToSliceV2(wu, 'service')),
-            internalEdges: v1EdgesToV2(result1.dependencyDAG.edges)
-        });
-        codegraph = result1.codegraph;
-        understandAnything = result1.understandAnything;
-    }
-    if (wantFile) {
-        if (pass1WorkUnits.length > 0) {
-            // Per-parent subdivision. In 'auto' mode, only parents where
-            // shouldSubdivide is not explicitly false qualify.
-            const qualifyingParents = granularity === 'auto'
-                ? pass1WorkUnits.filter((wu) => shouldSubdivide(wu).subdivide !== false)
-                : pass1WorkUnits;
-            const pass2Results = await Promise.all(qualifyingParents.map(async (parent) => {
-                const result = await decomposeSlices(rid, prdMarkdown, projectRoot, opts);
-                const filtered = filterWorkUnitsByScope(result.workUnits, parent.files);
-                const pass2Slices = filtered.map((wu, i) => workUnitToSliceV2(wu, 'file', {
-                    id: `${parent.id}.${i + 1}`,
-                    parentSliceId: parent.id
-                }));
-                const pass2 = {
-                    passNumber: 2,
-                    granularity: 'file',
-                    slices: pass2Slices,
-                    internalEdges: v1EdgesToV2(result.dependencyDAG.edges)
-                };
-                return pass2;
-            }));
-            passes.push(...pass2Results);
-        }
-        else if (!wantService) {
-            // file-only mode: call decomposeSlices once on the full scope and
-            // treat the result as Pass 2 (no parent subdivision).
-            const result = await decomposeSlices(rid, prdMarkdown, projectRoot, opts);
-            const slices = result.workUnits.map((wu) => workUnitToSliceV2(wu, 'file'));
-            passes.push({
-                passNumber: 2,
-                granularity: 'file',
-                slices,
-                internalEdges: v1EdgesToV2(result.dependencyDAG.edges)
-            });
-            codegraph = result.codegraph;
-            understandAnything = result.understandAnything;
-        }
-    }
-    let crossPassEdges = [];
-    let llmArbitrations = [];
-    if (passes.length > 1) {
-        const mergeResult = await merge(passes, {
-            projectRoot,
-            ...(opts.llmRunner ? { llmRunner: opts.llmRunner } : {})
-        });
-        crossPassEdges = mergeResult.edges;
-        llmArbitrations = mergeResult.llmCalls.map(toLlmArbitration);
-    }
-    return {
-        schemaVersion: 'v2',
-        rid,
-        generatedAt: new Date().toISOString(),
-        passes,
-        crossPassEdges,
-        llmArbitrations,
-        codegraph,
-        understandAnything,
-        partial: false
-    };
-}
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-/**
- * Convert a v1 `WorkUnit` into a v2 `SliceV2`. The `granularity` is supplied
- * by the caller (per-pass) so it matches the pass's `PassResult.granularity`.
- * `id` and `parentSliceId` default to the workUnit's own id and null
- * (i.e. a Pass 1 slice). For Pass 2 children, the orchestrator supplies
- * `${parent.id}.${i + 1}` as the new id and the parent's id as parent.
- */
-function workUnitToSliceV2(wu, granularity, overrides = {}) {
-    return {
-        id: overrides.id ?? wu.id,
-        label: wu.label,
-        granularity,
-        files: wu.files,
-        loc: wu.loc,
-        parentSliceId: overrides.parentSliceId ?? null,
-        semanticAnchor: `file:${wu.filePath}`
-    };
-}
-/**
- * Keep only workUnits that touch at least one file in the parent's scope.
- * Used to scope Pass 2 results to their parent slice's file set, since the
- * 6-stage algorithm does not accept a `scopeFilter` option.
- */
-function filterWorkUnitsByScope(wus, scope) {
-    const scopeSet = new Set(scope);
-    return wus.filter((wu) => wu.files.some((f) => scopeSet.has(f)));
-}
-/**
- * Map a v1 `DependencyEdge[]` (from the 6-stage algorithm's `dependencyDAG`)
- * to v2 `InternalEdge[]`. The two kinds unions are identical
- * (`'imports' | 'calls' | 'depends_on' | 'contains_flow' | 'flow_step'`), so
- * `kind` is a direct pass-through. `confidence` collapses `isSemantic`
- * (`true` → `'semantic'`, `false` → `'structural'`) to match the v2
- * `EdgeConfidence` union.
- */
-function v1EdgesToV2(v1Edges) {
-    return v1Edges.map((e) => ({
-        from: e.from,
-        to: e.to,
-        kind: e.kind,
-        weight: e.weight,
-        evidence: e.evidence,
-        confidence: e.isSemantic ? 'semantic' : 'structural'
-    }));
-}
-/**
- * Pure shape pass-through from `MergeResult.llmCalls` to v2 `LlmArbitration`.
- * The merger now populates `promptHash`/`input`/`output`/`confidence` itself;
- * we just coalesce a possible `null` `tokens` to a zeroed pair to satisfy
- * the non-nullable `LlmArbitration.tokens` contract.
- */
-function toLlmArbitration(c) {
-    return {
-        callId: c.callId,
-        promptHash: c.promptHash,
-        input: c.input,
-        output: c.output,
-        confidence: c.confidence,
-        tokens: c.tokens ?? { input: 0, output: 0 }
-    };
-}
-function zeroCodegraph() {
-    return {
-        nodes: 0,
-        edges: 0,
-        dbMB: 0,
-        freshness: 'unindexed',
-        affectedCrossFile: false,
-        note: 'no decomposition run'
-    };
-}
-function zeroUnderstand() {
-    return {
-        kgNodes: 0,
-        kgEdges: 0,
-        available: false,
-        fallback: 'structural-only',
-        note: 'no decomposition run'
-    };
-}

package/dist/src/services/slice/schema-router.d.ts

@@ -1,44 +0,0 @@
-/**
- * SchemaRouter — dual-read JSON router for `DecompositionResult` (v1/v2).
- *
- * v1 files (legacy, pre-Wave-1 slice decompose output) do NOT carry a
- * `schemaVersion` field; v2 files always carry `schemaVersion: 'v2'`.
- * The router reads the file, dispatches on the discriminator, and returns
- * the parsed object typed as `DecompositionResult` or `DecompositionResultV2`.
- *
- * Why a router (and not a parse-on-write migration):
- *  - v1 files may exist in user workspaces long after v2 ships; rewriting
- *    them on read would force a write-back side-effect that callers don't
- *    need (and breaks `peaks slice pick` which only needs the v1 fields).
- *  - The discriminated return type lets callers narrow once at the boundary
- *    (`schemaVersion === 'v2' ? handleV2(r) : handleV1(r)`) and stay typed
- *    downstream.
- *
- * Unknown versions throw `UnknownSchemaVersionError` so callers can
- * surface a clear migration hint instead of silently treating v3 as v1.
- */
-import type { DecompositionResult } from './slice-decompose-types.js';
-import type { DecompositionResultV2 } from './slice-topology-types.js';
-/**
- * Thrown by `readResult` when the JSON carries a `schemaVersion` value
- * that is neither absent (v1) nor `'v2'`. The `code` is the stable
- * machine-readable discriminator; downstream CLI surfaces should map it
- * to the appropriate exit code.
- */
-export declare class UnknownSchemaVersionError extends Error {
-    readonly code: "UNKNOWN_SCHEMA_VERSION";
-    constructor(message: string);
-}
-/**
- * Read a decomposition-result JSON file and return it typed as either
- * `DecompositionResult` (v1, no `schemaVersion` field) or
- * `DecompositionResultV2` (`schemaVersion: 'v2'`).
- *
- * Throws `UnknownSchemaVersionError` for any other `schemaVersion` value.
- */
-export declare function readResult(filePath: string): DecompositionResult | DecompositionResultV2;
-/**
- * Serialize a v1 or v2 decomposition result to disk as pretty-printed JSON.
- * The `schemaVersion` field (or its absence) is preserved as-is.
- */
-export declare function writeResult(filePath: string, result: DecompositionResult | DecompositionResultV2): void;

package/dist/src/services/slice/schema-router.js

@@ -1,61 +0,0 @@
-/**
- * SchemaRouter — dual-read JSON router for `DecompositionResult` (v1/v2).
- *
- * v1 files (legacy, pre-Wave-1 slice decompose output) do NOT carry a
- * `schemaVersion` field; v2 files always carry `schemaVersion: 'v2'`.
- * The router reads the file, dispatches on the discriminator, and returns
- * the parsed object typed as `DecompositionResult` or `DecompositionResultV2`.
- *
- * Why a router (and not a parse-on-write migration):
- *  - v1 files may exist in user workspaces long after v2 ships; rewriting
- *    them on read would force a write-back side-effect that callers don't
- *    need (and breaks `peaks slice pick` which only needs the v1 fields).
- *  - The discriminated return type lets callers narrow once at the boundary
- *    (`schemaVersion === 'v2' ? handleV2(r) : handleV1(r)`) and stay typed
- *    downstream.
- *
- * Unknown versions throw `UnknownSchemaVersionError` so callers can
- * surface a clear migration hint instead of silently treating v3 as v1.
- */
-import { readFileSync, writeFileSync } from 'node:fs';
-/**
- * Thrown by `readResult` when the JSON carries a `schemaVersion` value
- * that is neither absent (v1) nor `'v2'`. The `code` is the stable
- * machine-readable discriminator; downstream CLI surfaces should map it
- * to the appropriate exit code.
- */
-export class UnknownSchemaVersionError extends Error {
-    code = 'UNKNOWN_SCHEMA_VERSION';
-    constructor(message) {
-        super(message);
-        this.name = 'UnknownSchemaVersionError';
-    }
-}
-/**
- * Read a decomposition-result JSON file and return it typed as either
- * `DecompositionResult` (v1, no `schemaVersion` field) or
- * `DecompositionResultV2` (`schemaVersion: 'v2'`).
- *
- * Throws `UnknownSchemaVersionError` for any other `schemaVersion` value.
- */
-export function readResult(filePath) {
-    const parsed = JSON.parse(readFileSync(filePath, 'utf8'));
-    if (typeof parsed !== 'object' || parsed === null) {
-        throw new UnknownSchemaVersionError(`Unknown schemaVersion: ${String(parsed)}. Supported: v1 (no field), v2.`);
-    }
-    const schemaVersion = parsed.schemaVersion;
-    if (schemaVersion === 'v2') {
-        return parsed;
-    }
-    if (schemaVersion === undefined) {
-        return parsed;
-    }
-    throw new UnknownSchemaVersionError(`Unknown schemaVersion: ${String(schemaVersion)}. Supported: v1 (no field), v2.`);
-}
-/**
- * Serialize a v1 or v2 decomposition result to disk as pretty-printed JSON.
- * The `schemaVersion` field (or its absence) is preserved as-is.
- */
-export function writeResult(filePath, result) {
-    writeFileSync(filePath, JSON.stringify(result, null, 2), 'utf8');
-}

package/dist/src/services/slice/slice-archive-service.d.ts

@@ -1,20 +0,0 @@
-export declare const ARCHIVE_RETENTION_MS: number;
-export interface ArchiveResult {
-    readonly archivedCompleted: number;
-    readonly archivedInFlight: number;
-    readonly gcDeleted: number;
-}
-/** Build the canonical archive dir for a given session + slice id. */
-export declare function archiveDir(projectRoot: string, sessionId: string, sliceId: string): string;
-/** Build the in-flight subdir (records not yet disposed). */
-export declare function inFlightArchiveDir(projectRoot: string, sessionId: string, sliceId: string): string;
-/**
- * Archive the current `.peaks/_sub_agents/<sid>/` tree under
- * `<archiveDir>` (per the sliceId), separating completed vs in-flight.
- * Then run the 30-day GC over the archive dir.
- */
-export declare function archiveSubAgentRecords(projectRoot: string, options: {
-    sessionId: string;
-    sliceId: string;
-    now?: () => Date;
-}): ArchiveResult;

package/dist/src/services/slice/slice-archive-service.js

@@ -1,111 +0,0 @@
-/**
- * Slice #009 / G5 RL-8 — sub-agent dispatch record archival + 30-day GC.
- *
- * Called by the `peaks session finish` / `peaks session abandon` /
- * new-rid-startup hooks. Walks the per-session `.peaks/_sub_agents/<sid>/`
- * tree and moves completed + disposed records to
- * `.peaks/_runtime/<sid>/_archive/_sub_agents/<sliceId>/`.
- *
- * GC policy:
- *   - Records with `disposed: true` AND `outcome ∈ {success, failed,
- *     timeout, cancelled}` (not "no-execution") → archive + 30-day GC.
- *   - Records with `disposed: false` (any outcome) → archive but NOT
- *     GC'd. Next session will see them as still-pending in
- *     `_archive/.../in-flight/` and can resume reducer work.
- *
- * Lazy GC: `archiveSubAgentRecords` also scans the archive dir and
- * deletes entries older than 30 days. No cron, no background daemon.
- */
-import { existsSync, mkdirSync, readdirSync, readFileSync, renameSync, statSync, unlinkSync } from 'node:fs';
-import { join } from 'node:path';
-import { isDispatchStatus, isOutcome } from '../dispatch/dispatch-record-writer.js';
-export const ARCHIVE_RETENTION_MS = 30 * 24 * 60 * 60 * 1000; // 30 days
-/** Build the canonical archive dir for a given session + slice id. */
-export function archiveDir(projectRoot, sessionId, sliceId) {
-    return join(projectRoot, '.peaks', '_runtime', sessionId, '_archive', '_sub_agents', sliceId);
-}
-/** Build the in-flight subdir (records not yet disposed). */
-export function inFlightArchiveDir(projectRoot, sessionId, sliceId) {
-    return join(archiveDir(projectRoot, sessionId, sliceId), 'in-flight');
-}
-/**
- * Archive the current `.peaks/_sub_agents/<sid>/` tree under
- * `<archiveDir>` (per the sliceId), separating completed vs in-flight.
- * Then run the 30-day GC over the archive dir.
- */
-export function archiveSubAgentRecords(projectRoot, options) {
-    const now = options.now ?? (() => new Date());
-    const sourceDir = join(projectRoot, '.peaks', '_sub_agents', options.sessionId);
-    const completedDir = archiveDir(projectRoot, options.sessionId, options.sliceId);
-    const inFlightDir = inFlightArchiveDir(projectRoot, options.sessionId, options.sliceId);
-    mkdirSync(completedDir, { recursive: true });
-    mkdirSync(inFlightDir, { recursive: true });
-    let archivedCompleted = 0;
-    let archivedInFlight = 0;
-    if (existsSync(sourceDir)) {
-        for (const entry of readdirSync(sourceDir)) {
-            if (!entry.startsWith('dispatch-') || !entry.endsWith('.json'))
-                continue;
-            const src = join(sourceDir, entry);
-            const record = readRecordOrNull(src);
-            if (record === null)
-                continue;
-            if (record.disposed === true && isCompletedOutcome(record.outcome)) {
-                renameSync(src, join(completedDir, entry));
-                archivedCompleted += 1;
-            }
-            else {
-                renameSync(src, join(inFlightDir, entry));
-                archivedInFlight += 1;
-            }
-        }
-    }
-    // 30-day GC: walk the archive root (any sliceId), delete entries
-    // whose file mtime is older than the retention.
-    const gcDeleted = runGarbageCollection(completedDir, now().getTime());
-    return { archivedCompleted, archivedInFlight, gcDeleted };
-}
-function isCompletedOutcome(outcome) {
-    return outcome === 'success' || outcome === 'failed' || outcome === 'timeout' || outcome === 'cancelled';
-}
-function readRecordOrNull(path) {
-    try {
-        const raw = readFileSync(path, 'utf8');
-        const parsed = JSON.parse(raw);
-        if (typeof parsed !== 'object' || parsed === null)
-            return null;
-        const obj = parsed;
-        if (!isOutcome(obj.outcome) || !isDispatchStatus(obj.status))
-            return null;
-        if (typeof obj.disposed !== 'boolean')
-            return null;
-        return obj;
-    }
-    catch { // TODO(g2): legacy silent catch — grace: 1 minor release (v2.14.0)
-        return null;
-    }
-}
-function runGarbageCollection(dir, nowMs) {
-    if (!existsSync(dir))
-        return 0;
-    let deleted = 0;
-    for (const entry of readdirSync(dir)) {
-        const full = join(dir, entry);
-        try {
-            const stat = statSync(full);
-            if (stat.isDirectory()) {
-                deleted += runGarbageCollection(full, nowMs);
-                continue;
-            }
-            const ageMs = nowMs - stat.mtimeMs;
-            if (ageMs > ARCHIVE_RETENTION_MS) {
-                unlinkSync(full);
-                deleted += 1;
-            }
-        }
-        catch { // TODO(g2): legacy silent catch — grace: 1 minor release (v2.14.0)
-            /* skip unreadable; do not crash the archive op */
-        }
-    }
-    return deleted;
-}

package/dist/src/services/slice/slice-benchmark-service.d.ts

@@ -1,19 +0,0 @@
-/**
- * Slice benchmark wrapper (slice 2026-06-14-fzf-headroom-rollout).
- *
- * Wraps `decomposeSlices` with a thin observability layer that records
- * total wall time, codegraph call count, confidence distribution, and
- * input/output byte counts. The result is attached to the
- * DecompositionResult envelope only when `peaks slice decompose --benchmark`
- * is passed.
- *
- * The benchmark does NOT mutate the algorithm's output; it is pure
- * measurement. Codegraph call counting is achieved by wrapping the
- * caller-provided `codegraphRunner`.
- */
-import type { DecomposeOptions, DecompositionResult, SliceBenchmark } from './slice-decompose-types.js';
-export interface BenchmarkEnvelope {
-    benchmark: SliceBenchmark;
-    result: DecompositionResult;
-}
-export declare function decomposeSlicesWithBenchmark(rid: string, prdMarkdown: string, projectRoot: string, options?: DecomposeOptions): Promise<BenchmarkEnvelope>;

package/dist/src/services/slice/slice-benchmark-service.js

@@ -1,60 +0,0 @@
-/**
- * Slice benchmark wrapper (slice 2026-06-14-fzf-headroom-rollout).
- *
- * Wraps `decomposeSlices` with a thin observability layer that records
- * total wall time, codegraph call count, confidence distribution, and
- * input/output byte counts. The result is attached to the
- * DecompositionResult envelope only when `peaks slice decompose --benchmark`
- * is passed.
- *
- * The benchmark does NOT mutate the algorithm's output; it is pure
- * measurement. Codegraph call counting is achieved by wrapping the
- * caller-provided `codegraphRunner`.
- */
-import { Buffer } from 'node:buffer';
-import { decomposeSlices, defaultCodegraphRunner } from './slice-decompose-service.js';
-export async function decomposeSlicesWithBenchmark(rid, prdMarkdown, projectRoot, options = {}) {
-    const codegraphQueries = { count: 0 };
-    const baseRunner = options.codegraphRunner ?? defaultCodegraphRunner();
-    const wrappedRunner = {
-        query: async (text, root) => {
-            codegraphQueries.count += 1;
-            return baseRunner.query(text, root);
-        },
-        affected: async (files, root) => {
-            codegraphQueries.count += 1;
-            return baseRunner.affected(files, root);
-        },
-        status: async (root) => {
-            codegraphQueries.count += 1;
-            return baseRunner.status(root);
-        }
-    };
-    const t0 = Date.now();
-    const result = await decomposeSlices(rid, prdMarkdown, projectRoot, {
-        ...options,
-        codegraphRunner: wrappedRunner
-    });
-    const totalMs = Date.now() - t0;
-    const p50ConfidenceDistribution = { low: 0, mid: 0, high: 0 };
-    for (const batch of result.parallelBatches) {
-        for (const slice of batch.slices) {
-            if (slice.estimate.confidence === 'low')
-                p50ConfidenceDistribution.low += 1;
-            else if (slice.estimate.confidence === 'medium')
-                p50ConfidenceDistribution.mid += 1;
-            else
-                p50ConfidenceDistribution.high += 1;
-        }
-    }
-    const benchmark = {
-        rid,
-        totalMs,
-        codegraphQueries: codegraphQueries.count,
-        p50ConfidenceDistribution,
-        inputApproxBytes: { prd: Buffer.byteLength(prdMarkdown, 'utf8') },
-        outputJsonBytes: Buffer.byteLength(JSON.stringify(result), 'utf8'),
-        capturedAt: new Date().toISOString()
-    };
-    return { result, benchmark };
-}

package/dist/src/services/slice/slice-check-service.d.ts

@@ -1,2 +0,0 @@
-import type { SliceCheckOptions, SliceCheckResult } from './slice-check-types.js';
-export declare function sliceCheck(options: SliceCheckOptions): Promise<SliceCheckResult>;