project-tiny-context-harness 0.11.0 → 0.12.0

package/dist/commands/long-task-revision.js

@@ -1,177 +0,0 @@
-import path from "node:path";
-import { diagnoseAuthorityRevision } from "../lib/long-task-authority-revision-diagnosis.js";
-import { authorityRevisionDecisionNextAction } from "../lib/long-task-authority-revision-brief.js";
-import { projectAuthorityRevisionDecision } from "../lib/long-task-authority-revision-summary.js";
-import { canRetainProgressForSupportingContextRevision } from "../lib/long-task-context-authority.js";
-import { compileDeliveryContract } from "../lib/long-task-delivery-compiler.js";
-import { approvePendingAuthorityRevision, clearFinalReceipt, clearAuthorityRevision, commitActiveAuthority, invalidateDerivedProgress, loadActiveLongTaskAuthority, readPendingAuthorityRevision, stageCompiledDeliveryContract, } from "../lib/long-task-state.js";
-import { repositoryRoot } from "../lib/long-task-workspace.js";
-import { option, rejectOptions } from "./long-task-command-args.js";
-export async function handleLongTaskRevisionCommand(subcommand, workdir, args) {
-    if (subcommand === "compile")
-        await compile(workdir, args);
-    else if (subcommand === "diagnose-revision")
-        await diagnoseRevision(workdir, args);
-    else if (subcommand === "approve-authority-revision")
-        await approveRevision(workdir, args);
-    else
-        return false;
-    return true;
-}
-async function compile(workdir, args) {
-    const revise = args.length === 1 && args[0] === "--revise";
-    if (args.length && !revise)
-        throw new Error(`Unknown or injected arguments: ${args.join(" ")}`);
-    const root = await repositoryRoot(process.cwd());
-    const loaded = await loadActiveLongTaskAuthority(root, {
-        migrate_legacy: true,
-    });
-    const previous = loaded.authority?.authority_snapshot ?? null;
-    if (loaded.authority && loaded.authority.workdir !== path.resolve(workdir))
-        throw new Error(`active_task_exists:${loaded.authority.workdir}`);
-    const revisionCapture = {
-        proposal: null,
-    };
-    const compiled = await compileForCommand(workdir, revise, previous, revisionCapture);
-    if (loaded.authority && loaded.authority.task_id !== compiled.task.id)
-        throw new Error(`active_task_exists:${loaded.authority.workdir}`);
-    const preserveProgress = previous !== null &&
-        canRetainProgressForSupportingContextRevision(previous, compiled);
-    const stagedCache = await stageCompiledDeliveryContract(compiled);
-    let authorityCommitted = false;
-    try {
-        await commitActiveAuthority({
-            candidate: compiled,
-            expected_previous_identity: loaded.authority?.active_authority_identity ?? null,
-        });
-        authorityCommitted = true;
-        try {
-            await stagedCache.publish();
-        }
-        catch (error) {
-            await stagedCache.discard();
-            throw new Error(`compiled_cache_projection_publish_failed:${message(error)}`);
-        }
-    }
-    catch (error) {
-        if (!authorityCommitted)
-            await stagedCache.discard();
-        throw error;
-    }
-    if (!previous || previous.compiled_identity !== compiled.compiled_identity) {
-        if (!preserveProgress)
-            await invalidateDerivedProgress(workdir);
-        await clearFinalReceipt(compiled.repository_root, workdir);
-    }
-    await clearAuthorityRevision(workdir);
-    printCompileResult(compiled, previous, preserveProgress, revisionCapture.proposal);
-}
-function printCompileResult(compiled, previous, preserveProgress, revisionProposal) {
-    const firstAuthorityLock = previous === null;
-    const authorityChanged = previous !== null &&
-        previous.compiled_identity !== compiled.compiled_identity;
-    console.log(JSON.stringify({
-        status: "compiled",
-        lifecycle_event: firstAuthorityLock
-            ? "authority_locked"
-            : authorityChanged
-                ? "authority_revision_adopted"
-                : "authority_recompiled_unchanged",
-        delivery_completed_by_this_event: false,
-        native_goal_effect: "none",
-        task_id: compiled.task.id,
-        compiled_identity: compiled.compiled_identity,
-        authority_revision: compiled.authority_revision,
-        effective_risk: compiled.effective_risk,
-        outcomes: compiled.outcomes.map((outcome) => outcome.key),
-        claim_coverage: compiled.claim_coverage,
-        progress_preserved: preserveProgress,
-        authority_revision_change: revisionProposal
-            ? projectAuthorityRevisionDecision(revisionProposal)
-            : null,
-        next_action: firstAuthorityLock
-            ? "End this turn now. Do not implement, edit files, build, or test. After the user handles the model change in the host, ask them to reply exactly: model checkpoint cleared, continue. This is package-managed prompt guidance; Harness cannot observe the next host message or verify the model change."
-            : authorityChanged
-                ? "Run status or resume, then continue rolling implementation or repair under the adopted Authority Revision."
-                : "Continue rolling implementation or repair under the active Authority.",
-        execution_model_checkpoint: executionModelCheckpoint(firstAuthorityLock),
-    }));
-}
-async function compileForCommand(workdir, revise, previous, capture) {
-    try {
-        return await compileDeliveryContract(workdir, process.cwd(), {
-            revise,
-            previous_authority: previous,
-            on_authority_revision(value) {
-                capture.proposal = value;
-            },
-        });
-    }
-    catch (error) {
-        if (message(error).startsWith("authority_change_requires_user_decision:"))
-            await printPendingDecision(workdir, previous);
-        throw error;
-    }
-}
-async function printPendingDecision(workdir, previous) {
-    const pending = await readPendingAuthorityRevision(workdir);
-    if (!pending)
-        throw new Error("authority_revision_pending_state_missing");
-    const decision = projectAuthorityRevisionDecision(pending);
-    console.log(JSON.stringify({
-        status: "authority_revision_pending",
-        acceptance_authorized: false,
-        delivery_completed_by_this_event: false,
-        native_goal_effect: "none",
-        active_compiled_identity: previous?.compiled_identity ?? null,
-        pending_authority_revision: decision,
-        next_action: authorityRevisionDecisionNextAction(decision),
-    }));
-}
-async function diagnoseRevision(workdir, args) {
-    const outcome = option(args, "--outcome");
-    const check = option(args, "--check");
-    rejectOptions(args, ["--outcome", "--check"]);
-    const result = await diagnoseAuthorityRevision(workdir, { outcome, check });
-    console.log(JSON.stringify(result));
-    if (result.findings.length)
-        process.exitCode = 1;
-}
-async function approveRevision(workdir, args) {
-    const revision = option(args, "--revision");
-    rejectOptions(args, ["--revision"]);
-    if (!revision)
-        throw new Error("--revision requires a value");
-    await approvePendingAuthorityRevision(workdir, revision);
-    console.log(JSON.stringify({
-        status: "authority_revision_approved",
-        revision,
-        delivery_completed_by_this_event: false,
-        native_goal_effect: "none",
-        next_action: "Run compile --revise to atomically adopt the approved revision, then return to rolling implementation or repair.",
-    }));
-}
-function executionModelCheckpoint(firstAuthorityLock) {
-    if (!firstAuthorityLock)
-        return { required: false };
-    return {
-        required: true,
-        phase: "post_authority_lock_pre_implementation",
-        action: "change_model_in_host_then_continue",
-        resume_token: "model checkpoint cleared, continue",
-        turn_boundary: "end_current_turn",
-        blocked_until_resume: [
-            "product_implementation",
-            "file_edits",
-            "build",
-            "test_execution",
-        ],
-        model_change_owner: "host_or_user",
-        model_change_observable_by_harness: false,
-        generic_continue_satisfies: false,
-        message: "Authority Lock created. End the current turn before product implementation, file edits, builds, or tests. After handling the model change, reply exactly: model checkpoint cleared, continue. This is package-managed prompt guidance; Harness cannot observe the next host message or verify the model change.",
-    };
-}
-function message(error) {
-    return error instanceof Error ? error.message : String(error);
-}

package/dist/commands/long-task-workdir.d.ts

@@ -1,2 +0,0 @@
-export declare function resolveLongTaskCommandWorkdir(subcommand: string, workdirArgument: string | undefined): Promise<string>;
-export declare function canonicalLongTaskCommandWorkdir(workdir: string, allowMissing: boolean): Promise<string>;

package/dist/commands/long-task-workdir.js

@@ -1,23 +0,0 @@
-import { realpath } from "node:fs/promises";
-import path from "node:path";
-export async function resolveLongTaskCommandWorkdir(subcommand, workdirArgument) {
-    if (!workdirArgument)
-        throw new Error(`${subcommand} requires <workdir>`);
-    const lexicalWorkdir = path.resolve(process.cwd(), workdirArgument);
-    if (subcommand === "init")
-        return lexicalWorkdir;
-    return canonicalLongTaskCommandWorkdir(lexicalWorkdir, subcommand === "abandon");
-}
-export async function canonicalLongTaskCommandWorkdir(workdir, allowMissing) {
-    try {
-        return await realpath(workdir);
-    }
-    catch (error) {
-        if (allowMissing &&
-            error instanceof Error &&
-            "code" in error &&
-            error.code === "ENOENT")
-            return workdir;
-        throw error;
-    }
-}

package/dist/commands/long-task.d.ts

@@ -1 +0,0 @@
-export declare function longTask(args: string[]): Promise<void>;

package/dist/commands/long-task.js

@@ -1,212 +0,0 @@
-import path from "node:path";
-import { runDeliveryFinalGate } from "../lib/long-task-final-v2.js";
-import { closeDeliveryTask, doctorDeliveryTask, readDeliveryStatus, resumeDeliveryTask, stopCheckDeliveryTask, } from "../lib/long-task-status-v2.js";
-import { abandonLongTaskState, forceClearCorruptActiveState, } from "../lib/long-task-state.js";
-import { verifyDeliveryContract } from "../lib/long-task-verifier-v2.js";
-import { repositoryRoot } from "../lib/long-task-workspace.js";
-import { initializeLongTask, preflightLongTask, } from "./long-task-authoring.js";
-import { flag, option, rejectOptions, rejectUnknown, } from "./long-task-command-args.js";
-import { explainLongTask } from "./long-task-explain.js";
-import { handleLongTaskRevisionCommand } from "./long-task-revision.js";
-import { canonicalLongTaskCommandWorkdir, resolveLongTaskCommandWorkdir, } from "./long-task-workdir.js";
-import { previewVerificationExecution } from "../lib/long-task-verification-preview.js";
-import { externalConfirmationStatus, prepareExternalConfirmations, revokeExternalConfirmation, rotateExternalConfirmation, submitExternalConfirmation, } from "../lib/long-task-external-confirmation-plan.js";
-export async function longTask(args) {
-    const subcommand = args[0] ?? "help";
-    if (subcommand === "help")
-        return help();
-    if (subcommand === "external")
-        return external(args.slice(1));
-    const workdir = await resolveLongTaskCommandWorkdir(subcommand, args[1]);
-    if (subcommand === "init") {
-        rejectUnknown(args.slice(2), []);
-        await initializeLongTask(workdir);
-        console.log(JSON.stringify({ status: "initialized", workdir }));
-        return;
-    }
-    if (subcommand === "preflight") {
-        rejectUnknown(args.slice(2), []);
-        return preflightLongTask(workdir);
-    }
-    if (await handleLongTaskRevisionCommand(subcommand, workdir, args.slice(2)))
-        return;
-    if (subcommand === "explain") {
-        rejectUnknown(args.slice(2), []);
-        return explainLongTask(workdir);
-    }
-    if (subcommand === "verify")
-        return verify(workdir, args.slice(2));
-    if (subcommand === "status") {
-        rejectUnknown(args.slice(2), []);
-        console.log(JSON.stringify(await readDeliveryStatus(workdir), null, 2));
-        return;
-    }
-    if (subcommand === "resume") {
-        rejectUnknown(args.slice(2), []);
-        console.log(JSON.stringify(await resumeDeliveryTask(workdir), null, 2));
-        return;
-    }
-    if (subcommand === "doctor") {
-        rejectUnknown(args.slice(2), []);
-        console.log(JSON.stringify(await doctorDeliveryTask(workdir), null, 2));
-        return;
-    }
-    if (subcommand === "final-gate")
-        return finalGate(workdir, args.slice(2));
-    if (subcommand === "stop-check") {
-        const message = option(args.slice(2), "--message") ?? "";
-        rejectOptions(args.slice(2), ["--message"]);
-        const result = await stopCheckDeliveryTask(workdir, message);
-        console.log(JSON.stringify(result));
-        if (!result.continue)
-            process.exitCode = 1;
-        return;
-    }
-    if (subcommand === "close") {
-        rejectUnknown(args.slice(2), []);
-        const result = await closeDeliveryTask(workdir);
-        console.log(JSON.stringify({
-            status: result.status,
-            workdir,
-            workflow_status: result.workflow_status,
-            external_confirmations: result.external_confirmations,
-            external_confirmation_results: result.external_confirmation_results,
-            target_profile: result.target_profile,
-            target_state: result.target_state,
-            stage_results: result.stage_results,
-            acceptance_scope: result.acceptance_scope,
-            closed_scope: result.closed_scope,
-            native_goal_effect: result.native_goal_effect,
-        }));
-        return;
-    }
-    if (subcommand === "abandon") {
-        const forceCorruptState = args.length === 3 && args[2] === "--force-corrupt-state";
-        if (args.length > 2 && !forceCorruptState)
-            throw new Error(`Unknown or injected arguments: ${args.slice(2).join(" ")}`);
-        const root = await repositoryRoot(process.cwd());
-        if (forceCorruptState)
-            await forceClearCorruptActiveState(root, workdir);
-        else
-            await abandonLongTaskState(root, workdir);
-        console.log(JSON.stringify({
-            status: "abandoned",
-            workdir,
-            force_corrupt_state: forceCorruptState,
-        }));
-        return;
-    }
-    throw new Error(`Unknown long-task subcommand: ${subcommand}`);
-}
-async function verify(workdir, args) {
-    const explain = flag(args, "--explain");
-    const optionArgs = args.filter((value) => value !== "--explain");
-    const outcome = option(optionArgs, "--outcome");
-    const check = option(optionArgs, "--check");
-    rejectOptions(optionArgs, ["--outcome", "--check"]);
-    if (explain) {
-        console.log(JSON.stringify(await previewVerificationExecution(workdir, { outcome, check })));
-        return;
-    }
-    const result = await verifyDeliveryContract(workdir, { outcome, check });
-    console.log(JSON.stringify(result));
-    if (result.findings.length)
-        process.exitCode = 1;
-}
-async function finalGate(workdir, args) {
-    rejectUnknown(args, []);
-    const result = await runDeliveryFinalGate(workdir);
-    console.log(JSON.stringify({
-        ...result,
-        acceptance_scope: "declared_delivery_authority",
-        native_goal_effect: "none",
-    }));
-    if (result.workflow_status !== "machine_accepted" &&
-        result.workflow_status !== "delivery_accepted")
-        process.exitCode = 1;
-}
-async function external(args) {
-    const action = args[0];
-    const workdirArgument = args[1];
-    if (!action)
-        throw new Error("external requires prepare|submit|status|rotate|revoke");
-    if (!workdirArgument)
-        throw new Error(`external ${action} requires <workdir>`);
-    const workdir = await canonicalLongTaskCommandWorkdir(path.resolve(process.cwd(), workdirArgument), false);
-    const commandArgs = args.slice(2);
-    if (action === "prepare") {
-        const confirmation = option(commandArgs, "--confirmation");
-        rejectOptions(commandArgs, ["--confirmation"]);
-        console.log(JSON.stringify(await prepareExternalConfirmations(workdir, confirmation), null, 2));
-        return;
-    }
-    if (action === "submit") {
-        const confirmation = option(commandArgs, "--confirmation");
-        const record = option(commandArgs, "--record");
-        rejectOptions(commandArgs, ["--confirmation", "--record"]);
-        if (!confirmation)
-            throw new Error("--confirmation requires a value");
-        if (!record)
-            throw new Error("--record requires a value");
-        const result = await submitExternalConfirmation({
-            workdir,
-            confirmation_ref: confirmation,
-            record_path: path.resolve(process.cwd(), record),
-        });
-        console.log(JSON.stringify(result, null, 2));
-        if (result.state !== "fulfilled")
-            process.exitCode = 1;
-        return;
-    }
-    if (action === "status") {
-        rejectUnknown(commandArgs, []);
-        console.log(JSON.stringify(await externalConfirmationStatus(workdir), null, 2));
-        return;
-    }
-    if (action === "revoke") {
-        const confirmation = option(commandArgs, "--confirmation");
-        rejectOptions(commandArgs, ["--confirmation"]);
-        if (!confirmation)
-            throw new Error("--confirmation requires a value");
-        console.log(JSON.stringify(await revokeExternalConfirmation({
-            workdir,
-            confirmation_ref: confirmation,
-        }), null, 2));
-        return;
-    }
-    if (action === "rotate") {
-        const confirmation = option(commandArgs, "--confirmation");
-        rejectOptions(commandArgs, ["--confirmation"]);
-        if (!confirmation)
-            throw new Error("--confirmation requires a value");
-        console.log(JSON.stringify(await rotateExternalConfirmation({
-            workdir,
-            confirmation_ref: confirmation,
-        }), null, 2));
-        return;
-    }
-    throw new Error(`Unknown long-task external subcommand: ${action}`);
-}
-function help() {
-    console.log(`ty-context long-task commands:
-  init <workdir>
-  preflight <workdir>
-  compile <workdir>
-  compile <workdir> --revise
-  diagnose-revision <workdir> [--outcome <key>] [--check <key>]
-  approve-authority-revision <workdir> --revision <sha>
-  explain <workdir>
-  verify <workdir> [--outcome <key>] [--check <key>] [--explain]
-  status <workdir>
-  resume <workdir>
-  doctor <workdir>
-  final-gate <workdir>
-  external prepare <workdir> [--confirmation <key>]
-  external submit <workdir> --confirmation <key> --record <path>
-  external status <workdir>
-  external rotate <workdir> --confirmation <key>
-  external revoke <workdir> --confirmation <key>
-  stop-check <workdir> [--message <text>]
-  close <workdir>
-  abandon <workdir> [--force-corrupt-state]`);
-}

package/dist/commands/route.d.ts

@@ -1,15 +0,0 @@
-interface RouteOptions {
-    task?: string;
-    paths: string[];
-    terms: string[];
-    includes: string[];
-    format: "text" | "json";
-    explain: boolean;
-    case_sensitive: boolean;
-    max_search_results: number;
-    help: boolean;
-}
-export declare function route(args: string[]): Promise<void>;
-export declare function parseRouteArgs(args: string[]): RouteOptions;
-export declare function routeHelp(): string;
-export {};

package/dist/commands/route.js

@@ -1,142 +0,0 @@
-import { CLI_EXIT_CODES, CliCommandError } from "../lib/cli-exit.js";
-import { CONTEXT_ROUTE_BUDGETS } from "../lib/context-router/context-route-budget.js";
-import { renderContextRouteText } from "../lib/context-router/context-route-render.js";
-import { routeContext } from "../lib/context-router/context-route.js";
-export async function route(args) {
-    let options;
-    try {
-        options = parseRouteArgs(args);
-    }
-    catch (error) {
-        if (error instanceof CliCommandError)
-            throw error;
-        throw new CliCommandError(CLI_EXIT_CODES.arguments, error instanceof Error ? error.message : String(error), { cause: error });
-    }
-    if (options.help) {
-        console.log(routeHelp());
-        return;
-    }
-    if (options.task === undefined)
-        throw new CliCommandError(CLI_EXIT_CODES.arguments, "route requires --task <text>");
-    let result;
-    try {
-        result = await routeContext({
-            project_root: process.cwd(),
-            task: options.task,
-            paths: options.paths,
-            explicit_terms: options.terms,
-            includes: options.includes,
-            case_sensitive: options.case_sensitive,
-            max_search_results: options.max_search_results,
-        });
-    }
-    catch (error) {
-        if (error instanceof CliCommandError)
-            throw error;
-        throw new CliCommandError(CLI_EXIT_CODES.internal, `route failed internally: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
-    }
-    if (options.format === "json")
-        process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
-    else
-        process.stdout.write(renderContextRouteText(result, options.explain));
-    if (!result.catalog_valid)
-        process.exitCode = CLI_EXIT_CODES.catalog;
-    else if (!result.complete)
-        process.exitCode = CLI_EXIT_CODES.incomplete;
-}
-export function parseRouteArgs(args) {
-    const options = {
-        paths: [],
-        terms: [],
-        includes: [],
-        format: "text",
-        explain: false,
-        case_sensitive: false,
-        max_search_results: CONTEXT_ROUTE_BUDGETS.output_matches,
-        help: false,
-    };
-    for (let index = 0; index < args.length; index += 1) {
-        const argument = args[index];
-        if (argument === "--help" || argument === "-h")
-            options.help = true;
-        else if (argument === "--explain")
-            options.explain = true;
-        else if (argument === "--case-sensitive")
-            options.case_sensitive = true;
-        else if (argument === "--json")
-            options.format = "json";
-        else if (argument === "--task")
-            index = readValue(args, index, "--task", (value) => (options.task = value));
-        else if (argument.startsWith("--task="))
-            options.task = inlineValue(argument, "--task");
-        else if (argument === "--path")
-            index = readValue(args, index, "--path", (value) => options.paths.push(value));
-        else if (argument.startsWith("--path="))
-            options.paths.push(inlineValue(argument, "--path"));
-        else if (argument === "--term")
-            index = readValue(args, index, "--term", (value) => options.terms.push(value));
-        else if (argument.startsWith("--term="))
-            options.terms.push(inlineValue(argument, "--term"));
-        else if (argument === "--include")
-            index = readValue(args, index, "--include", (value) => options.includes.push(value));
-        else if (argument.startsWith("--include="))
-            options.includes.push(inlineValue(argument, "--include"));
-        else if (argument === "--format")
-            index = readValue(args, index, "--format", (value) => (options.format = parseFormat(value)));
-        else if (argument.startsWith("--format="))
-            options.format = parseFormat(inlineValue(argument, "--format"));
-        else if (argument === "--max-search-results")
-            index = readValue(args, index, "--max-search-results", (value) => (options.max_search_results = parseMaximum(value)));
-        else if (argument.startsWith("--max-search-results="))
-            options.max_search_results = parseMaximum(inlineValue(argument, "--max-search-results"));
-        else
-            throw new CliCommandError(CLI_EXIT_CODES.arguments, `unknown route argument: ${argument}`);
-    }
-    return options;
-}
-export function routeHelp() {
-    return `ty-context route (experimental, read-only):
-  route --task <text> [--path <repo-path>] [--term <literal>]
-        [--include <project_context/file.md>] [--case-sensitive]
-        [--max-search-results <1-${CONTEXT_ROUTE_BUDGETS.output_matches}>]
-        [--explain] [--format text|json]
-
-The Router scans registered and unregistered Context Markdown with literal,
-versioned budgets. It does not establish Authority, participate in the default
-footprint, or replace the Workflow-required bounded Context search.
-
-JSON schema v1 budgets: task=8192 UTF-8 bytes; automatic terms=32; explicit
-terms=32; term length=2-128 automatic/1-128 explicit Unicode code points;
-files=4096; per-file scan=1048576 bytes; aggregate scan=33554432 bytes;
-output matches=200 total/20 per file.
-
-Exit codes: 0 complete (warnings/ambiguity/unresolved allowed), 2 arguments,
-3 blocking Catalog, 4 incomplete budget, 5 I/O or path safety, 6 internal.`;
-}
-function readValue(args, index, flag, apply) {
-    const value = args[index + 1];
-    if (value === undefined || value.startsWith("--") || value.length === 0)
-        throw new CliCommandError(CLI_EXIT_CODES.arguments, `route ${flag} requires a value`);
-    apply(value);
-    return index + 1;
-}
-function inlineValue(argument, flag) {
-    const value = argument.slice(`${flag}=`.length);
-    if (!value)
-        throw new CliCommandError(CLI_EXIT_CODES.arguments, `route ${flag} requires a value`);
-    return value;
-}
-function parseFormat(value) {
-    if (value === "text" || value === "json")
-        return value;
-    throw new CliCommandError(CLI_EXIT_CODES.arguments, "route --format must be text or json");
-}
-function parseMaximum(value) {
-    const parsed = Number(value);
-    if (!Number.isInteger(parsed) ||
-        parsed < 1 ||
-        parsed > CONTEXT_ROUTE_BUDGETS.output_matches ||
-        String(parsed) !== value.trim())
-        throw new CliCommandError(CLI_EXIT_CODES.arguments, `route --max-search-results must be an integer from 1 to ${CONTEXT_ROUTE_BUDGETS.output_matches}`);
-    return parsed;
-}

package/dist/lib/compact-authoring-support.d.ts

@@ -1,22 +0,0 @@
-export declare function compactCommonFields<T extends Record<string, unknown>>(rows: T[], excluded: string[]): Record<string, unknown>;
-export declare function compactWithoutFields<T extends Record<string, unknown>>(value: T, fields: string[]): Record<string, unknown>;
-export declare function compactAuthoringTable<T extends object>(input: T[], excludedDefaults?: string[]): {
-    defaults: Record<string, unknown>;
-    columns: string[];
-    rows: unknown[][];
-};
-export declare function applyCompactAuthoringSelectors(base: Record<string, unknown>): {
-    value: Record<string, unknown>;
-    selectors: Array<{
-        key: string;
-        members: string[];
-    }>;
-};
-export declare function compactCapacityBudget(name: string, measured: number): number;
-export declare function compactDeterministicTemplates(records: Record<string, unknown>[], excludedFields: string[], keyPrefix: string): {
-    templates: Array<{
-        key: string;
-        value: Record<string, unknown>;
-    }>;
-    template_refs: string[];
-};