@qvac/harness 1.0.0-rc.1 → 1.0.0-rc.2

package/dist-lib/lib/capabilities/completion-loop/metrics.d.ts

@@ -1,5 +0,0 @@
-import type { MetricsState } from '../../machine/index.ts';
-import type { MetricsEvent } from '../completion.ts';
-import type { UsageBreakdown } from '../usage-breakdown.ts';
-export { foldMetrics, type MetricsState } from '../../machine/index.ts';
-export declare function metricsEvent(state: MetricsState, usage?: UsageBreakdown | null): MetricsEvent | null;

package/dist-lib/lib/capabilities/completion-loop/metrics.js

@@ -1,29 +0,0 @@
-export { foldMetrics } from '../../machine/index.js';
-export function metricsEvent(state, usage) {
-    if (!state.tokens) {
-        return null;
-    }
-    const event = {
-        type: 'metrics',
-        totalTokens: state.tokens,
-        durationMs: Math.round(state.durationMs),
-        timeToFirstToken: state.ttft,
-        promptTokensPerSecond: state.promptTokensPerSecond,
-        tokensPerSecond: state.durationMs > 0 ? (state.timedTokens / state.durationMs) * 1000 : undefined,
-        promptTokens: state.promptTokens,
-        cacheTokens: state.cacheTokens
-    };
-    if (state.ctxSize) {
-        event.ctxSize = state.ctxSize;
-    }
-    if (state.backends?.length) {
-        event.backends = state.backends;
-    }
-    if (usage) {
-        event.usage = usage;
-    }
-    if (state.stopReason) {
-        event.stopReason = state.stopReason;
-    }
-    return event;
-}

package/dist-lib/lib/capabilities/completion-loop/tool-execution.d.ts

@@ -1,60 +0,0 @@
-import { MAX_BLOCKED_REPEATS, toolCallKey, type ToolPreflight, type ToolPreflightFacts, type TrustedSourceFacts } from '../../machine/index.ts';
-import type { ToolCallWithCall } from '@qvac/sdk';
-import type { AbortSignal as BareAbortSignal } from 'bare-abort-controller';
-import { HookPipeline } from '../../hooks/pipeline.ts';
-import type { HookRejection } from '../../hooks/types.ts';
-import type { ToolCallDisplay, ToolExecutionOutcome } from '../../tool-call-display.ts';
-import { type TrustedSource } from '../../tools/outbound-guard.ts';
-import type { ApproveFn, ToolActivityFn, ToolDefinition, ToolEffect, ToolExecuteContext } from '../completion.ts';
-export { MAX_BLOCKED_REPEATS, toolCallKey };
-export declare function callSucceeded(result: unknown, outcome: ToolExecutionOutcome): boolean;
-export declare function settledFailure(result: unknown, outcome: ToolExecutionOutcome): boolean;
-export interface ExecuteCallOptions {
-    runId: string;
-    approve?: ApproveFn | undefined;
-    signal?: BareAbortSignal | undefined;
-    denied?: Set<string>;
-    sources?: readonly TrustedSource[];
-    sourceFacts?: readonly TrustedSourceFacts[];
-    pipeline: HookPipeline;
-    callId: string;
-    effect?: ToolEffect | undefined;
-    skipApprovals?: boolean;
-    preflight?: ToolPreflight;
-    onToolActivity?: ToolActivityFn;
-    intent?: string | undefined;
-    display?: ToolCallDisplay | undefined;
-}
-export interface ExecutedCall {
-    readonly result: unknown;
-    readonly outcome: ToolExecutionOutcome;
-    readonly executed: boolean;
-}
-export type { ToolPreflight };
-interface ToolPolicyOptions extends Pick<ExecuteCallOptions, 'sources' | 'sourceFacts' | 'denied' | 'effect' | 'skipApprovals'> {
-    key?: string;
-}
-export declare function preflightToolCall(tool: ToolDefinition, args: Record<string, unknown>, ctx: ToolExecuteContext, options?: ToolPolicyOptions): ToolPreflight;
-export declare function inspectToolPolicy(tool: ToolDefinition, args: Record<string, unknown>, ctx: ToolExecuteContext, options?: ToolPolicyOptions): ToolPreflightFacts;
-type ReadyToolPreflight = Extract<ToolPreflight, {
-    status: 'ready';
-}>;
-export declare function readyPreflightFromFacts(facts: ToolPreflightFacts): ReadyToolPreflight;
-export declare function executeCall(tool: ToolDefinition, args: Record<string, unknown>, ctx: ToolExecuteContext, { runId, approve, signal, denied, sources, sourceFacts, pipeline, callId, effect: classified, skipApprovals, preflight: prepared, onToolActivity, intent, display }: ExecuteCallOptions): Promise<ExecutedCall>;
-export interface ResolvedCall {
-    call: ToolCallWithCall;
-    tool?: ToolDefinition;
-    args: Record<string, unknown>;
-    rawCall?: string;
-    intent?: string;
-    rejection?: HookRejection;
-}
-export interface ResolveToolCallsOptions {
-    runId: string;
-    agentId: string | null;
-    pipeline: HookPipeline;
-    skillNames: readonly string[];
-    sandboxMode: boolean;
-    signal?: BareAbortSignal | undefined;
-}
-export declare function resolveToolCalls(toolCalls: ToolCallWithCall[], enabled: readonly ToolDefinition[], { runId, agentId, pipeline, skillNames, sandboxMode, signal }: ResolveToolCallsOptions): Promise<ResolvedCall[]>;

package/dist-lib/lib/capabilities/completion-loop/turns.js

@@ -1,112 +0,0 @@
-import { stripControlTokens } from '../../helpers/control-tokens.js';
-import { stripToolCallMarkup, toolCallMarkup } from '../../helpers/tool-call-markup.js';
-import { skillPreloadMessage } from '../../tools/skills/mention.js';
-import { SKILL_TOOL_NAME, WEB_SEARCH_TOOL_NAME } from '../tool-names.js';
-import { DIRECT_CALL_ID, toolResultHistoryEntry, toolResultTurn } from '../tool-turns.js';
-import { annotateLastUserTime } from '../../prompt.js';
-import { isFailureResultReference } from '../../machine/index.js';
-export function trustedSourcesFrom(history) {
-    const sources = [];
-    for (const entry of history) {
-        const text = String(entry.content ?? '');
-        if (entry.role === 'user') {
-            sources.push({ origin: 'user', text });
-        }
-        else if (entry.role === 'tool') {
-            sources.push({ origin: originOfToolTurn(text), text });
-        }
-    }
-    return sources;
-}
-function originOfToolTurn(text) {
-    return text.startsWith(`[Tool: ${SKILL_TOOL_NAME} (`) ? 'skill' : 'tool-result';
-}
-export function sanitizeTurn(turn) {
-    const stripped = stripControlTokens(turn.content);
-    const content = turn.role === 'assistant' ? stripToolCallMarkup(stripped) : stripped;
-    return content === turn.content ? turn : { ...turn, content };
-}
-export function lastUserContent(messages) {
-    for (let i = messages.length - 1; i >= 0; i--) {
-        const turn = messages[i];
-        if (turn?.role === 'user') {
-            return turn.content;
-        }
-    }
-    return '';
-}
-export function lastUserImages(messages) {
-    for (let i = messages.length - 1; i >= 0; i--) {
-        const turn = messages[i];
-        if (turn?.role === 'user') {
-            return turn.attachments ?? [];
-        }
-    }
-    return [];
-}
-export function explicitWebSearchQuery(text, tools, { skillPreloaded }) {
-    if (!tools.some((tool) => tool.name === WEB_SEARCH_TOOL_NAME)) {
-        return null;
-    }
-    if (explicitlyDisablesWebSearch(text)) {
-        return null;
-    }
-    const named = /\b(?:search|browse|look\s+up|find)\s+(?:the\s+)?(?:web|internet|online)\b/i.test(text);
-    const freshness = /\b(?:latest|current|recent)\s+(?:news|events)\b/i.test(text) ||
-        /\bwhat(?:'s|\s+is)\s+(?:the\s+)?(?:latest|current|recent)\b/i.test(text);
-    const explicit = named || (freshness && !skillPreloaded);
-    return explicit && text.trim() ? text.trim() : null;
-}
-function explicitlyDisablesWebSearch(text) {
-    return (/\b(?:do\s+not|don't|dont|never)\s+(?:search|browse|look\s+up|find|use)\s+(?:the\s+)?(?:web|internet|online)\b/i.test(text) ||
-        /\b(?:avoid|without)\s+(?:searching|browsing|using)\s+(?:the\s+)?(?:web|internet|online)\b/i.test(text));
-}
-export function directToolHistory(history, args, output, resultRef) {
-    return [
-        ...history,
-        {
-            role: 'assistant',
-            content: toolCallMarkup([{ name: WEB_SEARCH_TOOL_NAME, arguments: args }])
-        },
-        toolResultHistoryEntry({
-            name: WEB_SEARCH_TOOL_NAME,
-            id: DIRECT_CALL_ID,
-            output,
-            resultRef
-        })
-    ];
-}
-export function assistantToolTurn(contentText, calls) {
-    if (!calls.length || contentText.includes('<function=')) {
-        return contentText;
-    }
-    const markup = toolCallMarkup(calls);
-    return contentText ? `${contentText}\n${markup}` : markup;
-}
-export function preloadLastUser(messages, name, body) {
-    for (let i = messages.length - 1; i >= 0; i--) {
-        const turn = messages[i];
-        if (!turn || isFailureResultReference(turn)) {
-            continue;
-        }
-        if (turn?.role !== 'user') {
-            continue;
-        }
-        const next = [...messages];
-        next[i] = { ...turn, content: skillPreloadMessage(turn.content, name, body) };
-        return next;
-    }
-    return [...messages];
-}
-export function annotateCompletionHistoryLastUserTime(history, now) {
-    const result = [...history];
-    for (let index = result.length - 1; index >= 0; index--) {
-        const entry = result[index];
-        if (!entry || isFailureResultReference(entry) || entry.role !== 'user') {
-            continue;
-        }
-        result[index] = annotateLastUserTime([entry], now)[0] ?? entry;
-        break;
-    }
-    return result;
-}

package/dist-lib/lib/capabilities/completion-runtime.d.ts

@@ -1,46 +0,0 @@
-import type { AbortSignal as BareAbortSignal } from 'bare-abort-controller';
-import type { CompletionArgs, CompletionSdk } from './completion.ts';
-import type { CompletionContext } from '../../index.ts';
-import type { CompletionSkillEntry } from './completion-loop/index.ts';
-import { type ModelLoadOptions, type ModelLifecycleSdk, type PoolLike } from '../models/model-pool.ts';
-export type CompletionRuntimeRequest = CompletionContext & {
-    ctxSize?: number;
-};
-interface RuntimeLease {
-    modelId: string;
-    release(): void;
-}
-interface RuntimeAcquireOptions {
-    pool: PoolLike;
-    key: string;
-    open(): ReturnType<PoolLike['open']>;
-    signal?: BareAbortSignal;
-    prepare: () => Promise<boolean>;
-}
-interface RuntimeHarness {
-    _models: PoolLike;
-    _sdk: {
-        load(): Promise<CompletionSdk>;
-    };
-    _unloadIdleGenerators(): Promise<void>;
-    _completionLoadOptions(model: string, agent?: CompletionContext['agent']): ModelLoadOptions;
-    _completionSkills(agentId: string | null, model: string): Promise<CompletionSkillEntry[]>;
-    _acquireModelLease(options: RuntimeAcquireOptions): Promise<RuntimeLease | null>;
-    _makeRoomForCompletion(model: string, options: {
-        ctxSize?: number | undefined;
-        signal?: BareAbortSignal;
-    }): Promise<boolean>;
-    _loadModelLifecycleSdk(): Promise<ModelLifecycleSdk>;
-    suspended: boolean;
-    _runtimeDraining: boolean;
-    _assertNotClosing(): void;
-    _tools: CompletionArgs['tools'];
-}
-interface PreparedRuntime {
-    key: string;
-    args: Partial<CompletionArgs> & {
-        acquireRound: NonNullable<CompletionArgs['acquireRound']>;
-    };
-}
-export declare function prepareCompletionRuntime(harness: RuntimeHarness, request: CompletionRuntimeRequest): Promise<PreparedRuntime>;
-export {};

package/dist-lib/lib/capabilities/completion.d.ts

@@ -1,18 +0,0 @@
-import { type CompletionRun, type CompletionRuntime } from './completion-engine/driver.ts';
-import type { EngineBoot, EngineStep } from '../machine/index.ts';
-import type { CompletionArgs } from './completion-loop/index.ts';
-import type { CompletionSdk } from './types.ts';
-export * from './types.ts';
-export type { CompletionRun };
-export type { CompletionArgs } from './completion-loop/index.ts';
-interface CompletionRunOptions {
-    boot?: EngineBoot;
-    onStep?: (step: EngineStep) => Promise<void>;
-    hostAppendTimeoutMs?: number;
-    onDetached?: (pending: Promise<void>, runId?: string) => void;
-    requestDigestKey?: Uint8Array;
-    resumeRequest?: Partial<CompletionArgs>;
-    bootRequest?: unknown;
-}
-export { CONTEXT_OVERFLOW_MESSAGE, imageSettingsFrom, loadedSkillsFrom, skillInContext, skillLoadedTurn, toSdkTool, trustedSourcesFrom, unreadySkillState, type CompletionSkillEntry } from './completion-loop/index.ts';
-export declare function completion(sdk: CompletionSdk | CompletionRuntime, args: CompletionArgs, options?: CompletionRunOptions): CompletionRun;

package/dist-lib/lib/capabilities/completion.js

@@ -1,22 +0,0 @@
-import { trackCompletion } from '../completion-lifecycle.js';
-import { driveCompletion } from './completion-engine/driver.js';
-import { createRunLogRedactor } from '../run-log-redact.js';
-export * from './types.js';
-export { CONTEXT_OVERFLOW_MESSAGE, imageSettingsFrom, loadedSkillsFrom, skillInContext, skillLoadedTurn, toSdkTool, trustedSourcesFrom, unreadySkillState } from './completion-loop/index.js';
-export function completion(sdk, args, options = {}) {
-    const redactor = createRunLogRedactor();
-    redactor.registerTools(args.tools ?? []);
-    const runtime = typeof sdk === 'function' ? sdk : async () => ({ sdk });
-    const loadRuntime = async (request) => {
-        const loaded = await runtime(request);
-        redactor.registerTools(loaded.args?.tools ?? args.tools ?? []);
-        return loaded;
-    };
-    return trackCompletion((signal) => driveCompletion({ ...args, signal }, loadRuntime, {
-        ...options,
-        redact: redactor,
-        redactShared: redactor.redactShared,
-        redactOperationResult: redactor.redactOperationResult,
-        redactRecord: redactor.redactRecord
-    }), args.signal, () => { }).iterator;
-}

package/dist-lib/lib/helpers/recovery-required.d.ts

@@ -1 +0,0 @@
-export { RecoveryRequired, type Operation } from '../machine/index.ts';

package/dist-lib/lib/helpers/recovery-required.js

@@ -1 +0,0 @@
-export { RecoveryRequired } from '../machine/index.js';

package/dist-lib/lib/hooks/built-in/index.d.ts

@@ -1,4 +0,0 @@
-export { ArgRepairHook } from './arg-repair.ts';
-export { EgressGuardHook } from './egress.ts';
-export { SandboxHook } from './sandbox.ts';
-export { SkillCatalogGuardHook } from './skill-catalog.ts';

package/dist-lib/lib/hooks/built-in/index.js

@@ -1,4 +0,0 @@
-export { ArgRepairHook } from './arg-repair.js';
-export { EgressGuardHook } from './egress.js';
-export { SandboxHook } from './sandbox.js';
-export { SkillCatalogGuardHook } from './skill-catalog.js';

package/dist-lib/lib/hooks/pipeline.d.ts

@@ -1,24 +0,0 @@
-import type { ToolExecutionOutcome } from '../tool-call-display.ts';
-import type { HarnessHook, HookRejection, HookPhase, PostToolCallPayload, PreToolCallPayload, RunEndPayload, RunLifecyclePayload, RunStartPayload } from './types.ts';
-export type PreToolFold = {
-    ok: true;
-    args: Record<string, unknown>;
-} | {
-    ok: false;
-    rejection: HookRejection;
-};
-export interface PostToolFold {
-    result: unknown;
-    outcome?: ToolExecutionOutcome;
-}
-export declare function snapshotHooks(hooks?: readonly HarnessHook[]): readonly HarnessHook[];
-export declare class HookPipeline {
-    private readonly _behaviorHooks;
-    constructor(hooks?: readonly HarnessHook[]);
-    hasPhase(phase: HookPhase): boolean;
-    onRunLifecycle(payload: RunLifecyclePayload): Promise<void>;
-    onRunStart(payload: Omit<RunStartPayload, 'phase'>): Promise<void>;
-    onRunEnd(payload: Omit<RunEndPayload, 'phase'>): Promise<void>;
-    runPreToolFold(payload: Omit<PreToolCallPayload, 'phase'>): Promise<PreToolFold>;
-    runPostToolFold(payload: Omit<PostToolCallPayload, 'phase'>): Promise<PostToolFold>;
-}

package/dist-lib/lib/hooks/pipeline.js

@@ -1,74 +0,0 @@
-import { hlog } from '../log.js';
-import { normalizeToolExecutionOutcome } from '../helpers/run-outcome.js';
-import { harnessHooks } from './registry.js';
-import { runHooks } from './run.js';
-export function snapshotHooks(hooks = harnessHooks) {
-    const phaseCounts = new Map();
-    return Object.freeze(hooks.map((hook) => {
-        const count = (phaseCounts.get(hook.phase) ?? 0) + 1;
-        phaseCounts.set(hook.phase, count);
-        const name = hook.name?.trim() || `${hook.phase}:${count}`;
-        return Object.freeze({ phase: hook.phase, name, run: hook.run.bind(hook) });
-    }));
-}
-export class HookPipeline {
-    _behaviorHooks;
-    constructor(hooks = harnessHooks) {
-        this._behaviorHooks = snapshotHooks(hooks);
-    }
-    hasPhase(phase) {
-        return this._behaviorHooks.some((hook) => hook.phase === phase);
-    }
-    async onRunLifecycle(payload) {
-        const folded = await runHooks(this._behaviorHooks, payload);
-        if ('guidance' in folded) {
-            hlog('run hook failed', { stage: payload.phase, error: folded.error });
-        }
-    }
-    async onRunStart(payload) {
-        const folded = await runHooks(this._behaviorHooks, { phase: 'runStart', ...payload });
-        if ('guidance' in folded) {
-            hlog('run hook failed', { stage: 'runStart', error: folded.error });
-        }
-    }
-    async onRunEnd(payload) {
-        const folded = await runHooks(this._behaviorHooks, { phase: 'runEnd', ...payload });
-        if ('guidance' in folded) {
-            hlog('run hook failed', { stage: 'runEnd', error: folded.error });
-        }
-    }
-    async runPreToolFold(payload) {
-        const folded = await runHooks(this._behaviorHooks, { phase: 'preToolCall', ...payload });
-        if ('guidance' in folded) {
-            hlog('tool rejected: pre-hook refused the call', {
-                tool: payload.toolName,
-                hook: folded.hook,
-                phase: folded.phase
-            });
-            return { ok: false, rejection: folded };
-        }
-        return { ok: true, args: folded.args };
-    }
-    async runPostToolFold(payload) {
-        let result = payload.result;
-        let outcome = payload.outcome;
-        if (payload.executed) {
-            const folded = await runHooks(this._behaviorHooks, {
-                phase: 'postToolCall',
-                ...payload,
-                result
-            });
-            if ('guidance' in folded) {
-                result = folded;
-                outcome = { kind: 'guidance', message: folded.error };
-            }
-            else {
-                result = folded.result;
-            }
-        }
-        if (outcome !== undefined) {
-            outcome = normalizeToolExecutionOutcome(result, outcome);
-        }
-        return { result, outcome };
-    }
-}

package/dist-lib/lib/hooks/registry.d.ts

@@ -1,2 +0,0 @@
-import type { HarnessHook } from './types.ts';
-export declare const harnessHooks: HarnessHook[];

package/dist-lib/lib/hooks/registry.js

@@ -1,7 +0,0 @@
-import { ArgRepairHook, EgressGuardHook, SandboxHook, SkillCatalogGuardHook } from './built-in/index.js';
-export const harnessHooks = [
-    new ArgRepairHook(),
-    new EgressGuardHook(),
-    new SandboxHook(),
-    new SkillCatalogGuardHook()
-];

package/dist-lib/lib/machine/completion/actions/skills.d.ts

@@ -1,9 +0,0 @@
-import type { CompletionActionArgs, CompletionContext, SkillFailedPayload, PreloadInspectionOutput, SkillLoadOutput, SkillPreloadPayload, SkillReadyPayload, SkillToolExecutionSnapshot } from '../types.ts';
-export declare function requestPreload({ context, params }: CompletionActionArgs<SkillPreloadPayload>): Partial<CompletionContext>;
-export declare function authorizePreload({ params }: CompletionActionArgs<PreloadInspectionOutput>): Partial<CompletionContext>;
-export declare function settlePreloadFailure({ context, params }: CompletionActionArgs<PreloadInspectionOutput | SkillLoadOutput>): Partial<CompletionContext>;
-export declare function startSkillTool({ context, params }: CompletionActionArgs<SkillToolExecutionSnapshot>): Partial<CompletionContext>;
-export declare function finishSkill({ context, params }: CompletionActionArgs<SkillReadyPayload>): Partial<CompletionContext>;
-export declare function failSkill({ context, params }: CompletionActionArgs<SkillFailedPayload>): Partial<CompletionContext>;
-export declare function finishToolSkill(args: CompletionActionArgs<SkillReadyPayload>): Partial<CompletionContext>;
-export declare function failToolSkill(args: CompletionActionArgs<SkillFailedPayload>): Partial<CompletionContext>;

package/dist-lib/lib/machine/completion/actions/skills.js

@@ -1,83 +0,0 @@
-import { applyPreparation } from './completion.js';
-import { applyHistorySplice } from '../rules.js';
-export function requestPreload({ context, params }) {
-    const preparation = applyPreparation(context, params);
-    const skills = preparation.skills ?? context.skills;
-    return {
-        ...preparation,
-        skillPreload: { name: params.name },
-        pendingSearch: params.pendingSearch,
-        skills: {
-            ...skills,
-            loads: { ...skills.loads, [params.name]: { status: 'pending' } },
-            pending: skills.pending.includes(params.name)
-                ? skills.pending
-                : [...skills.pending, params.name]
-        }
-    };
-}
-export function authorizePreload({ params }) {
-    return {
-        skillPreload: { name: params.name, args: params.args, facts: params.facts ?? undefined }
-    };
-}
-export function settlePreloadFailure({ context, params }) {
-    const failure = 'failure' in params ? params.failure : null;
-    return failure ? failSkill({ context, params: failure }) : {};
-}
-export function startSkillTool({ context, params }) {
-    const name = params.skillName;
-    return {
-        execution: params,
-        skills: {
-            ...context.skills,
-            loads: { ...context.skills.loads, [name]: { status: 'pending' } },
-            pending: context.skills.pending.includes(name)
-                ? context.skills.pending
-                : [...context.skills.pending, name]
-        }
-    };
-}
-export function finishSkill({ context, params }) {
-    const loaded = context.skills.snapshot?.loaded ?? [];
-    const historyState = applyHistorySplice(context, params.history);
-    return {
-        skills: {
-            snapshot: { loaded: loaded.includes(params.name) ? loaded : [...loaded, params.name] },
-            loads: { ...context.skills.loads, [params.name]: { status: 'success' } },
-            pending: context.skills.pending.filter((name) => name !== params.name)
-        },
-        cacheKey: params.cacheable === false ? null : context.cacheKey,
-        ...historyState,
-        sources: params.source ? [...context.sources, params.source] : context.sources,
-        skillPreload: null
-    };
-}
-export function failSkill({ context, params }) {
-    const historyState = applyHistorySplice(context, params.history);
-    return {
-        skills: {
-            ...context.skills,
-            loads: { ...context.skills.loads, [params.name]: { status: 'error', error: params.error } },
-            pending: context.skills.pending.filter((name) => name !== params.name)
-        },
-        ...historyState,
-        skillPreload: null
-    };
-}
-export function finishToolSkill(args) {
-    return { ...finishSkill(args), ...finishSkillCall(args.context) };
-}
-export function failToolSkill(args) {
-    return { ...failSkill(args), ...finishSkillCall(args.context) };
-}
-function finishSkillCall(context) {
-    return {
-        pendingCall: null,
-        approval: { status: 'idle', key: null },
-        currentCall: null,
-        execution: null,
-        rejectedCall: null,
-        toolQueue: context.toolQueue.slice(1)
-    };
-}

package/dist-lib/lib/machine/engine.d.ts

@@ -1,93 +0,0 @@
-import { type SnapshotFrom } from 'xstate';
-import { createCompletionMachine } from './completion/machine.ts';
-import { type EnginePorts, type InvokeTracker } from './completion/ports.ts';
-import type { CompletionContext, EngineEvent, RunBudget } from './completion/types.ts';
-import { type Operation } from './errors.ts';
-import { type EngineBoot, type EngineStep } from '../run-log/protocol.ts';
-export { stableStringify } from './stable-stringify.ts';
-import { type RecoveryResolution, type RunRecord, type Receipt } from '../run-log/run-journal.ts';
-export type CompletionSnapshot = SnapshotFrom<ReturnType<typeof createCompletionMachine>>;
-export interface MachineDefinitionNode {
-    id: string;
-    type: string;
-    initial?: string;
-    tags: string[];
-    entry: string[];
-    exit: string[];
-    states?: Record<string, MachineDefinitionNode>;
-    on?: Record<string, MachineTransitionDefinition[]>;
-    always?: MachineTransitionDefinition[];
-    invoke: {
-        id: string;
-        src: string;
-    }[];
-}
-export interface MachineTransitionDefinition {
-    eventType: string;
-    target?: string[];
-    guard?: string;
-    actions?: string[];
-}
-export declare function completionMachineDefinition(): MachineDefinitionNode;
-export interface EngineRun {
-    runId: string;
-    resume?: boolean;
-    recovery?: RecoveryResolution[];
-    request?: unknown;
-    requestDigest?: string;
-    budget: RunBudget;
-    signal?: AbortSignal;
-    lockOwner?: object;
-    now?(): number;
-    start(run: {
-        operations: EngineOperationPort;
-        invokes: InvokeTracker;
-        boot: EngineBoot;
-    }): Promise<{
-        ports: EnginePorts;
-        context: CompletionContext;
-    }>;
-    settled?(snapshot: CompletionSnapshot): void;
-}
-export interface EngineOperationPort {
-    flush(): Promise<void>;
-    operation<Result>(operation: Operation, execute: () => Promise<Result>, facts?: OperationFactsPort, signal?: {
-        readonly aborted: boolean;
-    }): Promise<Result>;
-    getReceipt(id: string): Receipt | undefined;
-    commitResultFacts(id: string, facts: unknown): Promise<void>;
-    uncertainWrite(): import('./errors.ts').Operation | undefined;
-    settledCall(receiptId: string): boolean;
-    pendingArgumentsWereRedacted(snapshot: unknown): boolean | null;
-}
-export interface OperationFactsPort {
-    capture(): unknown;
-    restore(value: unknown): void;
-}
-export interface EngineBoundaryOptions {
-    boot?: EngineBoot;
-    onStep?: (step: EngineStep) => Promise<void>;
-    hostAppendTimeoutMs?: number;
-    redact?: <Value>(value: Value) => Value;
-    redactShared?: <Value>(value: Value) => Value;
-    redactOperationResult?: <Value>(operation: import('./errors.ts').Operation, value: Value) => Value;
-    redactRecord?: (record: RunRecord) => RunRecord;
-    redactStep?: (step: EngineStep) => EngineStep;
-    lockOwner?: object;
-    onDetached?: (pending: Promise<void>, runId?: string) => void;
-}
-export declare const HOST_APPEND_TIMEOUT_MS = 5000;
-export type EngineResult = {
-    status: 'replayed';
-} | {
-    status: 'paused';
-    snapshot: CompletionSnapshot;
-} | {
-    status: 'done';
-    snapshot: CompletionSnapshot;
-} | {
-    status: 'error';
-    snapshot: CompletionSnapshot;
-    error: unknown;
-};
-export declare function runEngine(run: EngineRun, options?: EngineBoundaryOptions): AsyncGenerator<EngineEvent, EngineResult>;

package/dist-lib/lib/machine/guards.d.ts

@@ -1,2 +0,0 @@
-export declare function isRecord(value: unknown): value is Record<string, unknown>;
-export declare function errorMessage(error: unknown): string;

package/dist-lib/lib/machine/guards.js

@@ -1,6 +0,0 @@
-export function isRecord(value) {
-    return typeof value === 'object' && value !== null;
-}
-export function errorMessage(error) {
-    return error instanceof Error ? error.message : String(error);
-}

package/dist-lib/lib/office/pptx.d.ts

@@ -1 +0,0 @@
-export declare const PPTX_EXTRACT: string;

package/dist-lib/lib/office/pptx.js

@@ -1,26 +0,0 @@
-export const PPTX_EXTRACT = `from pptx import Presentation
-from pptx.enum.shapes import MSO_SHAPE_TYPE
-from pathlib import Path
-
-def text(shapes):
-    for shape in shapes:
-        if shape.shape_type == MSO_SHAPE_TYPE.GROUP:
-            yield from text(shape.shapes)
-        elif shape.has_text_frame:
-            if shape.text.strip():
-                yield shape.text
-        elif shape.has_table:
-            for row in shape.table.rows:
-                cells = ["" if cell.is_spanned else cell.text.replace("\\n", " ") for cell in row.cells]
-                if any(cell.strip() for cell in cells):
-                    yield " | ".join(cells)
-
-with Path("extracted.txt").open("w", encoding="utf-8") as output:
-    for number, slide in enumerate(Presentation("input.pptx").slides, 1):
-        heading = False
-        for block in text(slide.shapes):
-            if not heading:
-                output.write("Slide " + str(number) + "\\n")
-                heading = True
-            output.write(block + "\\n")
-`;