@avocadostudio-ai/orchestrator-core 0.3.2 → 0.3.3

package/dist/durable/types.d.ts

@@ -0,0 +1,265 @@
+import type { Operation } from "@avocadostudio-ai/shared";
+export type FindingSeverity = "error" | "warning" | "info";
+/**
+ * `open` → a live problem. `fixed` is set by reconciliation, never by a rule.
+ * `dismissed` and `snoozed` are the user's decision and must survive every
+ * subsequent run — a checker whose dismissals evaporate is a checker people
+ * turn off in week two.
+ *
+ * The two are not synonyms, and the difference is a clock: `dismissed` means
+ * *never show me this again*, `snoozed` means *not this week*. A snooze without
+ * an expiry is a second word for dismiss, so a snoozed record carries
+ * `snoozedUntil` and `wakeSnoozedFindings` reopens it when that passes.
+ */
+export type FindingStatus = "open" | "snoozed" | "dismissed" | "fixed";
+export type FindingEvidence = {
+    source: "draft" | "rendered" | "model";
+    blockId?: string;
+    /**
+     * Carried so a client can select the block without a lookup. The editor's
+     * property panel collapses to its page-level fallback when it is handed an
+     * id with no type, so a finding that knows the block but not its type sends
+     * the user to a panel that cannot show them the field.
+     */
+    blockType?: string;
+    /**
+     * The block's own heading, for telling two blocks of one type apart. A page
+     * with three Card Grids yields three findings that all read
+     * `cards[0].imageAlt`; without this the panel cannot say which is which and
+     * the reader has to press "Go to" on each to find out.
+     */
+    blockLabel?: string;
+    /** Editable path into the block props, e.g. `meta.description`. */
+    path?: string;
+    excerpt?: string;
+};
+export type FindingInput = {
+    /** Stable across runs. Excludes the offending *value* — see `fingerprint`. */
+    fingerprint: string;
+    scopeKey: string;
+    slug: string;
+    ruleId: string;
+    agent: string;
+    severity: FindingSeverity;
+    /**
+     * Severity × how much the page matters, 0–1. See `finding-impact.ts`.
+     *
+     * Recomputed by every run rather than fixed at first sight, because the page
+     * weight it derives from moves: link a page from the nav and its findings
+     * become more important than they were this morning, without anything about
+     * the findings themselves having changed.
+     *
+     * Optional on the way in — a caller that has not scored its pages should get
+     * the neutral fallback rather than a made-up number.
+     */
+    impact?: number;
+    title: string;
+    detail?: string;
+    evidence?: FindingEvidence;
+    /** Ops that would resolve the finding. Applied only through the normal gate. */
+    proposedOps?: Operation[];
+};
+export type FindingRecord = FindingInput & {
+    id: string;
+    /** Always present on a record; `fallbackImpact` fills it for unscored rows. */
+    impact: number;
+    status: FindingStatus;
+    /** The run that most recently emitted this finding. Reconciliation reads it. */
+    lastRunId: string;
+    firstSeenAt: number;
+    lastSeenAt: number;
+    resolvedAt?: number;
+    /** When a `snoozed` record becomes `open` again. Set only for that status. */
+    snoozedUntil?: number;
+};
+export type FindingQuery = {
+    scopeKey: string;
+    slug?: string;
+    agent?: string;
+    status?: FindingStatus | FindingStatus[];
+    severity?: FindingSeverity;
+    limit?: number;
+};
+export type CheckRunTrigger = "manual" | "on_apply" | "on_publish" | "scheduled" | "webhook";
+export type CheckRunInput = {
+    id: string;
+    scopeKey: string;
+    agent: string;
+    trigger: CheckRunTrigger;
+    startedAt: number;
+};
+export type CheckRunRecord = CheckRunInput & {
+    finishedAt?: number;
+    pagesScanned: number;
+    findingsOpened: number;
+    findingsClosed: number;
+    /** Model spend for the judgement tier. Cost invisible is cost unbounded. */
+    costUsd: number;
+    error?: string;
+};
+export type CheckRunPatch = Partial<Omit<CheckRunRecord, keyof CheckRunInput>>;
+export type MemoryScope = "site" | "session" | "page";
+export type MemoryKind = "fact" | "preference" | "decision" | "glossary";
+export type MemorySource = "user" | "inferred" | "agent" | "import";
+export type MemoryStatus = "active" | "superseded" | "rejected";
+export type MemoryInput = {
+    scope: MemoryScope;
+    scopeKey: string;
+    kind: MemoryKind;
+    /** Namespaced, unique per (scope, scopeKey, kind). A new value supersedes. */
+    key: string;
+    value: string;
+    source: MemorySource;
+    /** traceId, findingId or run id — whatever lets a human audit the claim. */
+    sourceRef?: string;
+    /** 0–1. `inferred` should enter low; a wrong remembered fact steers silently. */
+    confidence?: number;
+};
+export type MemoryRecord = Required<Pick<MemoryInput, "confidence">> & MemoryInput & {
+    id: string;
+    status: MemoryStatus;
+    supersedesId?: string;
+    createdAt: number;
+    lastUsedAt?: number;
+    useCount: number;
+};
+export type MemoryQuery = {
+    scopeKey?: string;
+    scope?: MemoryScope;
+    kind?: MemoryKind | MemoryKind[];
+    status?: MemoryStatus;
+    limit?: number;
+};
+export type CorrectionOutcome = "accepted" | "edited" | "rejected" | "undone";
+export type CorrectionInput = {
+    traceId: string;
+    scopeKey: string;
+    slug?: string;
+    request: string;
+    proposed: Operation[];
+    outcome: CorrectionOutcome;
+    /** What actually landed, when the human edited rather than accepted. */
+    applied?: Operation[];
+};
+export type CorrectionRecord = CorrectionInput & {
+    id: string;
+    at: number;
+};
+export type CorrectionQuery = {
+    scopeKey?: string;
+    outcome?: CorrectionOutcome;
+    since?: number;
+    limit?: number;
+};
+export type ProposalStatus = "pending" | "approved" | "discarded" | "expired";
+/**
+ * `pendingApprovalPlanBySession` is an in-memory Map, not persisted, evicted by
+ * age. That is fine for "you typed a sentence and approved it ten seconds
+ * later" and useless for an agent that runs at 03:00: the plan it produced has
+ * nowhere to live until morning.
+ */
+export type ProposalInput = {
+    id: string;
+    scopeKey: string;
+    /** Which agent or chat turn produced it. */
+    origin: string;
+    summary: string;
+    ops: Operation[];
+    slugs: string[];
+    /** The finding this proposal resolves, when it came from one. */
+    findingId?: string;
+    /**
+     * Opaque to this store: whatever the producer needs to reconstruct its own
+     * richer object. The chat pipeline's `PendingApprovalPlan` carries a prompt
+     * hash, a model key, pending image ops and the destructive-gate reasons, none
+     * of which belong in a generic proposals table — and all of which have to
+     * survive a restart, or rehydration hands back a plan the approval path
+     * cannot execute.
+     *
+     * `ops`/`slugs`/`summary` stay typed so a consumer that only wants to show or
+     * apply the plan never has to know what produced it.
+     */
+    payload?: Record<string, unknown>;
+    createdAt: number;
+    expiresAt?: number;
+};
+export type ProposalRecord = ProposalInput & {
+    status: ProposalStatus;
+    resolvedAt?: number;
+};
+export type ProposalQuery = {
+    scopeKey: string;
+    status?: ProposalStatus;
+    limit?: number;
+};
+export interface DurableStore {
+    /**
+     * Upsert by fingerprint. An existing record keeps its `firstSeenAt` and — the
+     * part that matters — its `status`, so a dismissal survives every re-run. A
+     * record previously reconciled to `fixed` reopens.
+     *
+     * Returns counts, not records, because the caller is a run loop that wants a
+     * ledger line and not a page of rows.
+     */
+    recordFindings(runId: string, findings: FindingInput[]): Promise<{
+        opened: number;
+        updated: number;
+    }>;
+    /**
+     * Close every `open` or `snoozed` finding in scope that this run did not
+     * re-emit. The absence *is* the signal — nothing has to notice a problem went
+     * away.
+     *
+     * Snoozed rows are included because a snooze postpones the *report*, not the
+     * problem: leave them out and a finding somebody deferred on Monday, then
+     * fixed on Tuesday, comes back on Friday as an open finding about a page that
+     * is fine.
+     *
+     * `slugs` bounds it to what the run actually scanned: a run over two pages
+     * must not close findings on the other forty-three.
+     */
+    reconcileFindings(args: {
+        runId: string;
+        scopeKey: string;
+        slugs: string[];
+        agent?: string;
+        at?: number;
+    }): Promise<{
+        closed: number;
+    }>;
+    listFindings(query: FindingQuery): Promise<FindingRecord[]>;
+    getFinding(id: string): Promise<FindingRecord | null>;
+    /**
+     * `snoozed` derives its own `snoozedUntil` from `at` plus `SNOOZE_WINDOW_MS`
+     * rather than taking one, so every caller and every implementation agree on
+     * what a snooze is worth. Nothing else may set it.
+     */
+    setFindingStatus(id: string, status: FindingStatus, at?: number): Promise<void>;
+    /**
+     * Reopen snoozed findings whose window has passed. The read paths call it, so
+     * a snooze ends without anything having to be scheduled — the same shape as
+     * `expireProposals`, and for the same reason: there is no cron here.
+     */
+    wakeSnoozedFindings(scopeKey: string, now?: number): Promise<{
+        woken: number;
+    }>;
+    startCheckRun(run: CheckRunInput): Promise<CheckRunRecord>;
+    finishCheckRun(id: string, patch: CheckRunPatch): Promise<void>;
+    listCheckRuns(scopeKey: string, limit?: number): Promise<CheckRunRecord[]>;
+    /** Supersedes the active record with the same (scope, scopeKey, kind, key). */
+    putMemory(input: MemoryInput, at?: number): Promise<MemoryRecord>;
+    listMemory(query: MemoryQuery): Promise<MemoryRecord[]>;
+    /** Bump `lastUsedAt`/`useCount` for records that were actually sent to a model. */
+    touchMemory(ids: string[], at?: number): Promise<void>;
+    setMemoryStatus(id: string, status: MemoryStatus): Promise<void>;
+    recordCorrection(input: CorrectionInput, at?: number): Promise<CorrectionRecord>;
+    listCorrections(query?: CorrectionQuery): Promise<CorrectionRecord[]>;
+    putProposal(input: ProposalInput): Promise<ProposalRecord>;
+    getProposal(id: string): Promise<ProposalRecord | null>;
+    listProposals(query: ProposalQuery): Promise<ProposalRecord[]>;
+    setProposalStatus(id: string, status: ProposalStatus, at?: number): Promise<void>;
+    /** Sweep proposals past `expiresAt`. Returns how many were expired. */
+    expireProposals(now?: number): Promise<{
+        expired: number;
+    }>;
+}

package/dist/durable/types.js

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

package/dist/handler/create-orchestrator.d.ts

@@ -167,6 +167,10 @@ export interface CreateOrchestratorConfig {
      *
      * Omit it if you render Avocado's blocks (a scaffolded site does). The
      * declaration is exclusive: nothing outside the list is offered or accepted.
+     *
+     * Pass the same list to `createEditorApiHandler`. That handler serves
+     * `/api/editor/blocks`, the manifest the editor reads, and it is routinely
+     * asked for it before anything has caused this module to be evaluated.
      */
     blockTypes?: readonly string[];
     /**

package/dist/handler/create-orchestrator.js

@@ -34,6 +34,7 @@ import { historyStatus, historyLog, historyUndoAction, historyRedoAction, histor
 import { whoamiAction } from "../http/session-actions.js";
 import { blocksManifestAction } from "../http/blocks-actions.js";
 import { screenshotAction } from "../http/screenshot-actions.js";
+import { runChecksAction, listFindingsAction, listCheckRunsAction, updateFindingAction } from "../http/checks-actions.js";
 import { fileImageStore, formatImageChatFrame, generateImageAction, imageChatAction, imageChatStreamAction, interpretImageAction, validateImageChatRequest } from "../http/image-generate-actions.js";
 import { transcribeAudioAction, transcriptionUnavailable, validateAudioInput } from "../http/audio-actions.js";
 import { formatVariationFrame, parseVariationRequest, scopeVariationSession, variationsAction, variationsStreamAction } from "../http/variations-actions.js";
@@ -214,6 +215,10 @@ const SUPPORTED_ROUTES = [
     "POST /draft/bootstrap",
     "GET+PUT /draft/site-config",
     "POST /ops",
+    "POST /checks/run",
+    "GET /checks/findings",
+    "GET /checks/runs",
+    "POST /checks/findings/status",
     "GET /history/status",
     "GET /history/log",
     "POST /history/undo",
@@ -298,10 +303,18 @@ export function createOrchestrator(config = {}) {
     // up editing the bundled demo pages instead of the site's real content.
     const effectiveSiteId = config.adapter ? (config.siteId ?? "library") : config.siteId;
     /*
-     * Declared at mount, before any request can build a manifest. The registry
-     * holds this on `globalThis`, so it survives Next duplicating these modules
-     * across the RSC / SSR / route-handler layers — the declaration made here has
-     * to be visible to `/api/editor/blocks` in another copy.
+     * The registry holds this on `globalThis`, so it survives Next duplicating
+     * these modules across the RSC / SSR / route-handler layers — the declaration
+     * made here is visible to `/api/editor/blocks` in another copy.
+     *
+     * It is *not*, however, made "at mount" in any sense that covers the other
+     * route. This runs when this route's module is first evaluated, which Next
+     * does on the first request to this route — so an editor that asks
+     * `/api/editor/blocks` before anything has touched `/api/avocado/*` sees an
+     * undeclared catalogue and is offered Avocado's built-ins alongside the
+     * site's own. Pass `blockTypes` to `createEditorApiHandler` as well; it
+     * declares the same catalogue while building the manifest, which is the point
+     * that actually needs it.
      */
     if (config.blockTypes)
         declareBlockCatalogue(config.blockTypes);
@@ -1164,6 +1177,56 @@ export function createOrchestrator(config = {}) {
          * The bodies are the same functions the Fastify app calls, so undo means
          * the same thing in both. See orchestrator-core/http/history-actions.ts.
          */
+        /*
+         * ---- Checks: findings, runs, and their status --------------------------
+         *
+         * Mounted here in the same commit that adds them to Fastify, rather than
+         * after somebody notices. Every route in `history-actions.ts` exists
+         * because that lesson was learned the expensive way: a UI shipped a button
+         * whose endpoint answered "not handled by createOrchestrator()".
+         */
+        if (request.method === "POST" && path === "/checks/run") {
+            const runtime = await getRuntime();
+            await runtime.ready;
+            let raw;
+            try {
+                raw = await request.json();
+            }
+            catch {
+                return jsonResponse({ error: "invalid JSON body" }, { status: 400, cors });
+            }
+            const body = (raw ?? {});
+            // The draft has to exist before it can be checked — a cold library-mode
+            // process has no pages until this runs, and an unchecked empty session
+            // would report every page as missing because there are none.
+            const scoped = scope(body.session, body.siteId);
+            await runtime.bootstrapCache.ensure(scoped, runtime.adapter, runtime.log);
+            return actionResponse(await runChecksAction(body, runtime.log), cors);
+        }
+        if (request.method === "GET" && path === "/checks/findings") {
+            const runtime = await getRuntime();
+            await runtime.ready;
+            const query = Object.fromEntries(url.searchParams);
+            return actionResponse(await listFindingsAction(query, runtime.log), cors);
+        }
+        if (request.method === "GET" && path === "/checks/runs") {
+            const runtime = await getRuntime();
+            await runtime.ready;
+            const query = Object.fromEntries(url.searchParams);
+            return actionResponse(await listCheckRunsAction(query), cors);
+        }
+        if (request.method === "POST" && path === "/checks/findings/status") {
+            const runtime = await getRuntime();
+            await runtime.ready;
+            let raw;
+            try {
+                raw = await request.json();
+            }
+            catch {
+                return jsonResponse({ error: "invalid JSON body" }, { status: 400, cors });
+            }
+            return actionResponse(await updateFindingAction((raw ?? {})), cors);
+        }
         if (request.method === "GET" && path === "/history/status") {
             const runtime = await getRuntime();
             await runtime.ready;

package/dist/http/audio-actions.d.ts

@@ -15,7 +15,7 @@
  * keep their own reader — Fastify streams the part (aborting mid-upload once it
  * crosses the cap), library mode reads a `File` off `request.formData()`.
  */
-import type { ActionResult } from "./history-actions.js";
+import type { ActionResult } from "./history-actions.ts";
 export type { ActionResult };
 /**
  * Formats both providers read natively.

package/dist/http/checks-actions.d.ts

@@ -0,0 +1,39 @@
+import type { CheckRunTrigger } from "../durable/types.ts";
+import type { Logger } from "../logger.ts";
+import type { ActionResult } from "./history-actions.ts";
+export type { ActionResult };
+export type ChecksScope = {
+    session?: string;
+    siteId?: string;
+};
+export type RunChecksParams = ChecksScope & {
+    /** Restrict the scan. Cross-page rules still see the whole site. */
+    slugs?: string[];
+    trigger?: CheckRunTrigger;
+};
+/** POST /checks/run — scan the session's draft and reconcile its findings. */
+export declare function runChecksAction(params: RunChecksParams, log?: Logger): Promise<ActionResult>;
+export type ListFindingsParams = ChecksScope & {
+    slug?: string;
+    agent?: string;
+    status?: string;
+    limit?: number;
+};
+/** GET /checks/findings — what is currently wrong, newest and most severe first. */
+export declare function listFindingsAction(params: ListFindingsParams, log?: Logger): Promise<ActionResult>;
+/** GET /checks/runs — the ledger, including what each run cost. */
+export declare function listCheckRunsAction(params: ChecksScope & {
+    limit?: number;
+}): Promise<ActionResult>;
+export type UpdateFindingParams = ChecksScope & {
+    id?: string;
+    status?: string;
+};
+/**
+ * POST /checks/findings/status — dismiss, snooze, or reopen one finding.
+ *
+ * `fixed` is not accepted: it is reconciliation's word, meaning "a run looked
+ * and the problem was gone". Letting a client assert it would put a finding
+ * into a state the next run immediately contradicts.
+ */
+export declare function updateFindingAction(params: UpdateFindingParams): Promise<ActionResult>;

package/dist/http/checks-actions.js

@@ -0,0 +1,122 @@
+import { scopedSessionKey } from "../state/session-state.js";
+import { getDurableStore, durableHealth } from "../durable/durable-store-singleton.js";
+import { runChecksForSession } from "../checks/session-runner.js";
+/*
+ * The checks HTTP surface, as transport-agnostic actions.
+ *
+ * Written this way from the first commit rather than as Fastify handlers,
+ * because the alternative is already documented next door: `history-actions.ts`
+ * exists because `/history/undo` was wired into Fastify only, and answered "not
+ * handled by createOrchestrator()" in a library-mode UI that shows an Undo
+ * button unconditionally. A findings panel added to one transport would be a
+ * panel that is permanently empty in the other.
+ */
+const badRequest = (error) => ({ code: 400, body: { error } });
+/**
+ * What the panel asks for when it does not say. Snoozed rows are excluded:
+ * including them is what made Snooze a button that removed a row until the next
+ * refresh put it straight back.
+ */
+const DEFAULT_STATUSES = ["open"];
+/**
+ * End any snooze whose week is up, on the way in.
+ *
+ * There is no scheduler in this process, so the wake has to hang off something
+ * that already happens; the two read paths are the only moments a snooze
+ * expiring is observable. Best-effort — a failed sweep leaves a finding hidden a
+ * little longer, which is not worth failing a request over.
+ */
+async function wakeSnoozed(scopeKey, log) {
+    try {
+        await getDurableStore().wakeSnoozedFindings(scopeKey);
+    }
+    catch (err) {
+        log?.warn({ err: String(err), scopeKey }, "waking snoozed findings failed");
+    }
+}
+/** POST /checks/run — scan the session's draft and reconcile its findings. */
+export async function runChecksAction(params, log) {
+    if (!params.session)
+        return badRequest("session is required");
+    const scopeKey = scopedSessionKey(params.session, params.siteId);
+    try {
+        await wakeSnoozed(scopeKey, log);
+        const run = await runChecksForSession({
+            scopeKey,
+            trigger: params.trigger ?? "manual",
+            ...(params.slugs?.length ? { slugs: params.slugs } : {})
+        });
+        const findings = await getDurableStore().listFindings({ scopeKey, status: DEFAULT_STATUSES });
+        // `durable` rides along on every response: findings written to the
+        // in-memory fallback look identical to durable ones until the process
+        // restarts, and a scheduled run is exactly when nobody is watching a log.
+        return { code: 200, body: { run, findings, durable: durableHealth() } };
+    }
+    catch (err) {
+        const reason = err instanceof Error ? err.message : String(err);
+        log?.error({ err: reason, scopeKey }, "checks run failed");
+        return { code: 500, body: { error: reason } };
+    }
+}
+const FINDING_STATUSES = ["open", "snoozed", "dismissed", "fixed"];
+function parseStatuses(raw) {
+    if (!raw)
+        return undefined;
+    const wanted = raw
+        .split(",")
+        .map((s) => s.trim())
+        .filter((s) => FINDING_STATUSES.includes(s));
+    return wanted.length > 0 ? wanted : undefined;
+}
+/** GET /checks/findings — what is currently wrong, newest and most severe first. */
+export async function listFindingsAction(params, log) {
+    if (!params.session)
+        return badRequest("session is required");
+    const scopeKey = scopedSessionKey(params.session, params.siteId);
+    await wakeSnoozed(scopeKey, log);
+    const status = parseStatuses(params.status) ?? DEFAULT_STATUSES;
+    const limitRaw = Number(params.limit);
+    const findings = await getDurableStore().listFindings({
+        scopeKey,
+        status,
+        ...(params.slug ? { slug: params.slug } : {}),
+        ...(params.agent ? { agent: params.agent } : {}),
+        ...(Number.isFinite(limitRaw) && limitRaw > 0 ? { limit: Math.floor(limitRaw) } : {})
+    });
+    return { code: 200, body: { findings, durable: durableHealth() } };
+}
+/** GET /checks/runs — the ledger, including what each run cost. */
+export async function listCheckRunsAction(params) {
+    if (!params.session)
+        return badRequest("session is required");
+    const scopeKey = scopedSessionKey(params.session, params.siteId);
+    const limitRaw = Number(params.limit);
+    const runs = await getDurableStore().listCheckRuns(scopeKey, Number.isFinite(limitRaw) && limitRaw > 0 ? Math.floor(limitRaw) : 50);
+    return { code: 200, body: { runs } };
+}
+/**
+ * POST /checks/findings/status — dismiss, snooze, or reopen one finding.
+ *
+ * `fixed` is not accepted: it is reconciliation's word, meaning "a run looked
+ * and the problem was gone". Letting a client assert it would put a finding
+ * into a state the next run immediately contradicts.
+ */
+export async function updateFindingAction(params) {
+    if (!params.session)
+        return badRequest("session is required");
+    if (!params.id)
+        return badRequest("id is required");
+    const status = params.status;
+    if (status !== "dismissed" && status !== "snoozed" && status !== "open") {
+        return badRequest("status must be dismissed, snoozed or open");
+    }
+    const scopeKey = scopedSessionKey(params.session, params.siteId);
+    const store = getDurableStore();
+    const finding = await store.getFinding(params.id);
+    // Scope check, not politeness: findings are per-site and the id is opaque, so
+    // without this any session could dismiss any other site's finding.
+    if (!finding || finding.scopeKey !== scopeKey)
+        return { code: 404, body: { error: "finding not found" } };
+    await store.setFindingStatus(params.id, status);
+    return { code: 200, body: { finding: await store.getFinding(params.id) } };
+}

package/dist/http/history-actions.d.ts

@@ -15,7 +15,7 @@
  * status code and body to send; neither Fastify nor `Response` appears in this
  * file.
  */
-import type { Logger } from "../logger.js";
+import type { Logger } from "../logger.ts";
 /** What a caller sends. `siteId` scopes the session; both transports pass it through. */
 export type HistoryScope = {
     session?: string;

package/dist/http/image-generate-actions.d.ts

@@ -23,8 +23,8 @@
  * Each function returns the status code and body to send, or emits frames;
  * neither Fastify nor `Response` appears in this file.
  */
-import type { Logger } from "../logger.js";
-import type { ActionResult } from "./history-actions.js";
+import type { Logger } from "../logger.ts";
+import type { ActionResult } from "./history-actions.ts";
 export type { ActionResult };
 /**
  * The one seam that decides where a generated image is written and what URL

package/dist/http/ops-actions.d.ts

@@ -17,8 +17,8 @@
  * own again.
  */
 import type { BlockManifest, Operation } from "@avocadostudio-ai/shared";
-import { type SkippedOperation } from "../ops/ops-engine.js";
-import type { ActionResult } from "./history-actions.js";
+import { type SkippedOperation } from "../ops/ops-engine.ts";
+import type { ActionResult } from "./history-actions.ts";
 export type { ActionResult };
 /**
  * Never mutates state, so it skips undo snapshotting, the version bump and the

package/dist/http/publish-actions.d.ts

@@ -16,10 +16,10 @@
  * neither Fastify nor `Response` appears in this file.
  */
 import type { PageDoc, SiteConfig } from "@avocadostudio-ai/shared";
-import type { PublishLogStatus } from "../state/session-state.js";
-import { refreshPublishStatusFromVercel } from "../publish/publish-helpers.js";
-import type { Logger } from "../logger.js";
-import type { ActionResult } from "./history-actions.js";
+import type { PublishLogStatus } from "../state/session-state.ts";
+import { refreshPublishStatusFromVercel } from "../publish/publish-helpers.ts";
+import type { Logger } from "../logger.ts";
+import type { ActionResult } from "./history-actions.ts";
 export type { ActionResult };
 /**
  * What "the site as it is currently live" resolves to.

package/dist/http/restore-actions.d.ts

@@ -14,9 +14,9 @@
  * function returns the status code and body to send; neither Fastify nor
  * `Response` appears in this file.
  */
-import { listRestoreSnapshots, loadPublishedSnapshotFromCommit, deletePublishSnapshot } from "../publish/publish-helpers.js";
-import type { Logger } from "../logger.js";
-import type { ActionResult } from "./history-actions.js";
+import { listRestoreSnapshots, loadPublishedSnapshotFromCommit, deletePublishSnapshot } from "../publish/publish-helpers.ts";
+import type { Logger } from "../logger.ts";
+import type { ActionResult } from "./history-actions.ts";
 export type { ActionResult };
 /**
  * The three git-backed helpers, injectable so the actions are testable.

package/dist/http/screenshot-actions.d.ts

@@ -24,8 +24,8 @@
  * page. So the path is declarable: per request, per registered site, or via
  * `createOrchestrator({ draftPath })`.
  */
-import type { Logger } from "../logger.js";
-import type { ActionResult } from "./history-actions.js";
+import type { Logger } from "../logger.ts";
+import type { ActionResult } from "./history-actions.ts";
 export type { ActionResult };
 export type ScreenshotParams = {
     session?: string;

package/dist/http/session-actions.d.ts

@@ -17,7 +17,7 @@
  * embedding its own editor, and it would answer a question no embedded caller
  * should be asking.
  */
-import type { ActionResult } from "./history-actions.js";
+import type { ActionResult } from "./history-actions.ts";
 export type { ActionResult };
 /**
  * The caller's bound session and a summary of its state.

package/dist/http/telemetry-feedback-actions.d.ts

@@ -15,8 +15,8 @@
  * status code and body to send; neither Fastify nor `Response` appears in this
  * file.
  */
-import type { FeedbackStore } from "../telemetry/feedback-store.js";
-import type { ActionResult } from "./history-actions.js";
+import type { FeedbackStore } from "../telemetry/feedback-store.ts";
+import type { ActionResult } from "./history-actions.ts";
 export type { ActionResult };
 /**
  * The store is a parameter, not a module singleton.

package/dist/http/unsplash-actions.d.ts

@@ -15,8 +15,8 @@
  * orchestrator runtime is ready, and why this file needs no collaborators
  * beyond an access key and a `fetch`.
  */
-import type { Logger } from "../logger.js";
-import type { ActionResult } from "./history-actions.js";
+import type { Logger } from "../logger.ts";
+import type { ActionResult } from "./history-actions.ts";
 export type { ActionResult };
 /**
  * Raw query values, straight off the wire.