@spendgraph/harness 0.1.0 → 0.2.0

package/dist/core/schema/types.d.ts

@@ -1,58 +0,0 @@
-/**
- * Typed prompt fields — what a `{placeholder}` accepts, and how it renders.
- *
- * Deliberately a copy of `lib/fields.ts` rather than an import. This package is
- * published and depends on nothing; reaching into the app for a type would make
- * every installed copy break the next time the app moved a file. The two are
- * kept in step by the wire format, which is the only contract that matters.
- *
- * A field type is two things, and the second is the one that gets forgotten: an
- * input contract, and a rendering rule. Everything ends up interpolated into a
- * string, so `{max_words}` given `50` has to become `"50"` and `{tags}` given
- * `["a","b"]` has to become something the prompt author chose rather than
- * whatever the first implementation happened to do.
- *
- * Deliberately not called `Variable`: a tool's arguments and an agent node's
- * inputs are the same problem, and naming this after prompts guarantees it gets
- * written twice more with three different meanings for `required`.
- */
-export type FieldType = "string" | "text" | "number" | "boolean" | "enum" | "list" | "json";
-export interface FieldSpec {
-    /** Matches the `{placeholder}` in the blocks or question. */
-    name: string;
-    type: FieldType;
-    /** A missing required field throws before anything is sent. */
-    required: boolean;
-    /**
-     * Substituted verbatim when the field is absent — already-rendered text, not
-     * a value to coerce. A `list` default is the joined string, a `json` default
-     * is the printed JSON. Authored once by a human rather than typed per run, so
-     * asking for it in final form is simpler than parsing it back per type.
-     */
-    default?: string;
-    /**
-     * What the field means. Shown in the UI, and given to the optimizer's
-     * reflector — knowing what a field is *for* is the difference between a
-     * useful prompt mutation and a guess.
-     */
-    description?: string;
-    /** `enum` — the permitted values. */
-    options?: string[];
-    /** `list` — what joins the items. Defaults to ", ". */
-    separator?: string;
-    /** `number` — inclusive bounds. */
-    min?: number;
-    max?: number;
-    /** `string` | `text` — rejected above this length. */
-    maxLength?: number;
-    /** `boolean` — words to render instead of "true"/"false". */
-    trueText?: string;
-    falseText?: string;
-    /**
-     * This is the field a dataset varies.
-     *
-     * A prompt declaring `{question}` plus 200 stored values for it *is* a
-     * 200-case dataset; this flag is what says which field those values fill.
-     */
-    datasetKey?: boolean;
-}

package/dist/core/schema/validate.d.ts

@@ -1,28 +0,0 @@
-import type { FieldSpec } from "./types.js";
-export type FieldError = {
-    field: string;
-    message: string;
-};
-export declare class FieldValidationError extends Error {
-    readonly errors: FieldError[];
-    constructor(errors: FieldError[]);
-}
-/** Absent means absent. An empty string is a value someone chose to send. */
-export declare function isMissing(value: unknown): boolean;
-/**
- * Coercions shared with the renderer.
- *
- * Shared deliberately: if the checker and the renderer disagreed, a value could
- * pass validation and then render as something else — a request you paid for
- * and cannot explain.
- */
-export declare function toNumber(value: unknown): number;
-export declare function toBoolean(value: unknown): boolean;
-/**
- * Everything wrong with these values, rather than the first thing.
- *
- * Values with no matching field are ignored, not reported: a stored prompt keeps
- * values for placeholders that were later edited out, and treating a stale key
- * as an error would fail a prompt that renders perfectly well.
- */
-export declare function validateFields(values: Record<string, unknown>, spec: FieldSpec[]): FieldError[];

package/dist/core/schema/validate.js

@@ -1,98 +0,0 @@
-export class FieldValidationError extends Error {
-    errors;
-    constructor(errors) {
-        super(errors.map((e) => `${e.field}: ${e.message}`).join("; "));
-        this.name = "FieldValidationError";
-        this.errors = errors;
-    }
-}
-/** Absent means absent. An empty string is a value someone chose to send. */
-export function isMissing(value) {
-    return value === undefined || value === null;
-}
-/**
- * Coercions shared with the renderer.
- *
- * Shared deliberately: if the checker and the renderer disagreed, a value could
- * pass validation and then render as something else — a request you paid for
- * and cannot explain.
- */
-export function toNumber(value) {
-    return typeof value === "number" ? value : Number(String(value).trim());
-}
-export function toBoolean(value) {
-    return typeof value === "boolean" ? value : String(value).toLowerCase() === "true";
-}
-function checkOne(field, value) {
-    switch (field.type) {
-        case "string":
-        case "text": {
-            const s = String(value);
-            return field.maxLength !== undefined && s.length > field.maxLength
-                ? `is ${s.length} characters, over the limit of ${field.maxLength}`
-                : null;
-        }
-        case "number": {
-            const n = toNumber(value);
-            if (!Number.isFinite(n))
-                return `expects a number, got ${JSON.stringify(value)}`;
-            if (field.min !== undefined && n < field.min)
-                return `is ${n}, below the minimum of ${field.min}`;
-            if (field.max !== undefined && n > field.max)
-                return `is ${n}, above the maximum of ${field.max}`;
-            return null;
-        }
-        case "boolean": {
-            if (typeof value === "boolean")
-                return null;
-            const s = String(value).toLowerCase();
-            return s === "true" || s === "false"
-                ? null
-                : `expects true or false, got ${JSON.stringify(value)}`;
-        }
-        case "enum": {
-            const options = field.options ?? [];
-            if (options.length === 0)
-                return "is an enum with no options declared";
-            return options.includes(String(value))
-                ? null
-                : `must be one of ${options.join(" | ")}, got ${JSON.stringify(value)}`;
-        }
-        case "list":
-            return Array.isArray(value) ? null : `expects an array, got ${typeof value}`;
-        case "json":
-            try {
-                // Catches cycles and BigInt, which otherwise reach the provider as a
-                // crash — at which point the request has already been paid for.
-                JSON.stringify(value);
-                return null;
-            }
-            catch (err) {
-                return `is not serialisable: ${err.message}`;
-            }
-    }
-}
-/**
- * Everything wrong with these values, rather than the first thing.
- *
- * Values with no matching field are ignored, not reported: a stored prompt keeps
- * values for placeholders that were later edited out, and treating a stale key
- * as an error would fail a prompt that renders perfectly well.
- */
-export function validateFields(values, spec) {
-    const errors = [];
-    for (const field of spec) {
-        const value = values[field.name];
-        if (isMissing(value)) {
-            if (field.default !== undefined)
-                continue;
-            if (field.required)
-                errors.push({ field: field.name, message: "is required" });
-            continue; // optional and unset — the placeholder stays visible
-        }
-        const problem = checkOne(field, value);
-        if (problem)
-            errors.push({ field: field.name, message: problem });
-    }
-    return errors;
-}

package/dist/harness.d.ts

@@ -1,128 +0,0 @@
-import { type ClientOptions } from "./core/client.js";
-import { type CacheOptions } from "./core/cache.js";
-import type { DatasetCase, DatasetSummary, Prompt, ReportInput, PromptVersion, RunOptions, RunResult, ValuesFor } from "./prompt/types.js";
-export interface HarnessOptions extends Omit<ClientOptions, "apiKey" | "baseUrl"> {
-    /** spendgraph API key (sg_…). Without it, `pull` throws and `report` no-ops. */
-    apiKey: string | undefined;
-    baseUrl: string;
-    cache?: CacheOptions;
-    /** Max requests in flight for sample() and runAll(). Default 4. */
-    concurrency?: number;
-    /**
-     * Stop spending past this, in micro-dollars. Omit and the client warns once
-     * that it is unbounded; pass `null` to say you meant it.
-     */
-    maxCostMicros?: number | null;
-    /**
-     * Called when a `report` is dropped. Reporting never throws, so without this
-     * a misconfigured key is invisible until somebody notices the empty table.
-     */
-    onReportError?: (err: unknown) => void;
-    /**
-     * Called when a background prompt refresh fails.
-     *
-     * The case worth wiring: renaming a prompt mints a new slug, so a service
-     * pulling by the old one keeps serving the wording it last saw. That is the
-     * safe behaviour, but it should not be a silent one.
-     */
-    onPullError?: (err: unknown, handle: string) => void;
-}
-export declare class Harness {
-    private readonly client;
-    private readonly cache;
-    private readonly hasKey;
-    private readonly onReportError?;
-    private readonly concurrency;
-    private readonly budget;
-    constructor(opts: HarnessOptions);
-    /**
-     * A prompt, from cache when one is warm.
-     *
-     * Serves a stale copy immediately and refreshes behind the caller, so an edit
-     * takes effect within a TTL without any request ever paying for the fetch.
-     *
-     * Takes an id or a slug — the server resolves either. Cached under whatever
-     * you passed, so pulling the same prompt both ways keeps two entries.
-     *
-     * A slug is only as stable as the prompt's name: renaming it server-side
-     * mints a new one and the old stops resolving, at which point the background
-     * refresh 404s and this keeps serving the wording it last saw. Pull by id
-     * where a handle has to outlive an edit to the name.
-     */
-    pull(promptId: string): Promise<Prompt>;
-    /**
-     * Runs the prompt server-side and records the rollout.
-     *
-     * The batch path. A production request should pull, render and report
-     * instead — this adds a hop and makes spendgraph a dependency of the caller's
-     * uptime, which is the right trade for evaluation and the wrong one for a
-     * user waiting on a response.
-     */
-    run<K extends string>(promptId: K, values?: ValuesFor<K>, opts?: RunOptions): Promise<RunResult>;
-    /** k repetitions of one case. Always k results, failures included. */
-    sample<K extends string>(promptId: K, values?: ValuesFor<K>, opts?: RunOptions & {
-        k?: number;
-        concurrency?: number;
-    }): Promise<RunResult[]>;
-    /** One rollout per model — the playground's comparison, headless. */
-    runAll<K extends string>(promptId: K, values?: ValuesFor<K>, opts?: RunOptions & {
-        models?: string[];
-        concurrency?: number;
-    }): Promise<RunResult[]>;
-    /** The dataset a prompt is evaluated against, with its split counts. */
-    cases(promptId: string): Promise<DatasetSummary>;
-    /**
-     * Replaces the whole dataset.
-     *
-     * A dataset is a set: "which cases am I evaluating against" has one answer at
-     * a time, and a merge would leave no way to remove a case or to know from the
-     * outside what the set currently is.
-     */
-    setCases(promptId: string, cases: DatasetCase[]): Promise<Omit<DatasetSummary, "cases">>;
-    /** Micro-dollars this client has spent on runs it initiated. */
-    spent(): number;
-    /** What is left of the ceiling, or Infinity when none was set. */
-    remaining(): number;
-    /** Every wording this prompt has had, newest first. */
-    versions(promptId: string, opts?: {
-        origin?: "user" | "assay";
-        limit?: number;
-    }): Promise<{
-        versions: PromptVersion[];
-        currentVersionId: string | null;
-    }>;
-    /**
-     * Serves this version from now on.
-     *
-     * Invalidates the cache: a promotion that left a warm entry in place would
-     * keep sending the old wording for up to a TTL, which is the one moment a
-     * caller is actively watching for the change.
-     */
-    promote(promptId: string, versionId: string): Promise<{
-        promoted: string;
-        previous?: string | null;
-        unchanged?: boolean;
-    }>;
-    /**
-     * Drops whatever is cached, so the next pull refetches.
-     *
-     * Both handles, not just the one passed. `pull` keys the cache on whatever
-     * string it was given, so the same prompt can sit under its uuid and its
-     * slug at once — and `promote` is only reachable with a uuid while the
-     * dashboard teaches pulling by slug. Dropping one key left the other warm
-     * for a full TTL, still rendering the wording the promotion replaced, which
-     * is the exact case this method exists to prevent.
-     */
-    invalidate(promptId?: string): void;
-    /**
-     * Records a rollout the caller executed.
-     *
-     * Never throws and never rejects. This sits beside a user-facing request that
-     * has already been answered; telemetry that can break the thing it measures
-     * is worse than no telemetry. Failures go to `onReportError` and are dropped.
-     *
-     * Returns the rollout id it used, so a caller that wants to retry the exact
-     * same record can pass it back and land on one row.
-     */
-    report(promptId: string, input: ReportInput): Promise<string>;
-}

package/dist/harness.js

@@ -1,187 +0,0 @@
-import { Client } from "./core/client.js";
-import { Budget } from "./core/budget.js";
-import { PullCache } from "./core/cache.js";
-import { pullWithCache } from "./core/pull.js";
-import { serializeFields } from "./core/schema/serialize.js";
-import { renderMessages } from "./prompt/render.js";
-import { newRolloutId, runAcrossModels, runOnce, sampleRuns } from "./prompt/run.js";
-export class Harness {
-    client;
-    cache;
-    hasKey;
-    onReportError;
-    concurrency;
-    budget;
-    constructor(opts) {
-        const { cache, onReportError, onPullError, concurrency, maxCostMicros, ...clientOpts } = opts;
-        this.client = new Client(clientOpts);
-        // Spread first, then the wiring — the other order let a `cache` object
-        // carrying `onRefreshError: undefined` silently discard `onPullError`.
-        this.cache = new PullCache({
-            ...cache,
-            onRefreshError: cache?.onRefreshError ?? onPullError,
-            // What a cached prompt answers to, so an invalidation by uuid also
-            // catches the slug production actually pulled by, and vice versa.
-            identify: (p) => [p.id, p.slug].filter((v) => Boolean(v)),
-        });
-        this.hasKey = Boolean(opts.apiKey);
-        this.onReportError = onReportError;
-        this.concurrency = Math.max(1, concurrency ?? 4);
-        this.budget = new Budget("maxCostMicros" in opts ? maxCostMicros : undefined);
-    }
-    /**
-     * A prompt, from cache when one is warm.
-     *
-     * Serves a stale copy immediately and refreshes behind the caller, so an edit
-     * takes effect within a TTL without any request ever paying for the fetch.
-     *
-     * Takes an id or a slug — the server resolves either. Cached under whatever
-     * you passed, so pulling the same prompt both ways keeps two entries.
-     *
-     * A slug is only as stable as the prompt's name: renaming it server-side
-     * mints a new one and the old stops resolving, at which point the background
-     * refresh 404s and this keeps serving the wording it last saw. Pull by id
-     * where a handle has to outlive an edit to the name.
-     */
-    async pull(promptId) {
-        const payload = await pullWithCache(this.cache, promptId, async () => {
-            const res = await this.client.request(`/api/v1/prompts/${encodeURIComponent(promptId)}`);
-            return res.prompt;
-        });
-        const serialize = (values = {}) => serializeFields(values, payload.fieldSpec ?? []);
-        return {
-            id: payload.id,
-            name: payload.name,
-            slug: payload.slug ?? null,
-            fields: payload.fieldSpec ?? [],
-            versionId: payload.currentVersionId ?? null,
-            models: payload.models ?? [],
-            serialize,
-            render: (values = {}) => renderMessages(payload.blocks, payload.question, serialize(values)),
-        };
-    }
-    /**
-     * Runs the prompt server-side and records the rollout.
-     *
-     * The batch path. A production request should pull, render and report
-     * instead — this adds a hop and makes spendgraph a dependency of the caller's
-     * uptime, which is the right trade for evaluation and the wrong one for a
-     * user waiting on a response.
-     */
-    async run(promptId, values = {}, opts = {}) {
-        return runOnce(this.client, promptId, values, opts, this.budget);
-    }
-    /** k repetitions of one case. Always k results, failures included. */
-    async sample(promptId, values = {}, opts = {}) {
-        return sampleRuns(this.client, promptId, values, { concurrency: this.concurrency, ...opts }, this.budget);
-    }
-    /** One rollout per model — the playground's comparison, headless. */
-    async runAll(promptId, values = {}, opts = {}) {
-        const models = opts.models ?? (await this.pull(promptId)).models;
-        if (models.length === 0) {
-            throw new Error("No models given and the prompt has none saved.");
-        }
-        return runAcrossModels(this.client, promptId, values, models, { concurrency: this.concurrency, ...opts }, this.budget);
-    }
-    /** The dataset a prompt is evaluated against, with its split counts. */
-    async cases(promptId) {
-        return this.client.request(`/api/v1/prompts/${encodeURIComponent(promptId)}/cases`);
-    }
-    /**
-     * Replaces the whole dataset.
-     *
-     * A dataset is a set: "which cases am I evaluating against" has one answer at
-     * a time, and a merge would leave no way to remove a case or to know from the
-     * outside what the set currently is.
-     */
-    async setCases(promptId, cases) {
-        return this.client.request(`/api/v1/prompts/${encodeURIComponent(promptId)}/cases`, { method: "PUT", body: JSON.stringify({ cases }) });
-    }
-    /** Micro-dollars this client has spent on runs it initiated. */
-    spent() {
-        return this.budget.spent();
-    }
-    /** What is left of the ceiling, or Infinity when none was set. */
-    remaining() {
-        return this.budget.remaining();
-    }
-    /** Every wording this prompt has had, newest first. */
-    async versions(promptId, opts = {}) {
-        const q = new URLSearchParams();
-        if (opts.origin)
-            q.set("origin", opts.origin);
-        if (opts.limit)
-            q.set("limit", String(opts.limit));
-        const suffix = q.size ? `?${q}` : "";
-        return this.client.request(`/api/v1/prompts/${encodeURIComponent(promptId)}/versions${suffix}`);
-    }
-    /**
-     * Serves this version from now on.
-     *
-     * Invalidates the cache: a promotion that left a warm entry in place would
-     * keep sending the old wording for up to a TTL, which is the one moment a
-     * caller is actively watching for the change.
-     */
-    async promote(promptId, versionId) {
-        const res = await this.client.request(`/api/v1/prompts/${encodeURIComponent(promptId)}/versions`, {
-            method: "POST",
-            body: JSON.stringify({ versionId }),
-        });
-        this.invalidate(promptId);
-        return res;
-    }
-    /**
-     * Drops whatever is cached, so the next pull refetches.
-     *
-     * Both handles, not just the one passed. `pull` keys the cache on whatever
-     * string it was given, so the same prompt can sit under its uuid and its
-     * slug at once — and `promote` is only reachable with a uuid while the
-     * dashboard teaches pulling by slug. Dropping one key left the other warm
-     * for a full TTL, still rendering the wording the promotion replaced, which
-     * is the exact case this method exists to prevent.
-     */
-    invalidate(promptId) {
-        if (!promptId) {
-            this.cache.clear();
-            return;
-        }
-        // Matched on the payload, not on the key handed in. Reading the entry under
-        // `promptId` only finds the sibling when that key was the cached one — and
-        // the case this exists for is the opposite: production pulled by slug, so
-        // the slug is the only key, while `promote` is reachable only with a uuid.
-        for (const key of this.cache.keysWhere((p) => p.id === promptId || p.slug === promptId)) {
-            this.cache.delete(key);
-        }
-        // Always, even with nothing stored under it: a cold isolate has a fetch in
-        // flight under this handle and no entry yet, and delete is what bumps the
-        // epoch that stops the in-flight result being stored after the promotion.
-        this.cache.delete(promptId);
-        // Recorded against the name as well, so a fetch still in flight — which
-        // carries no payload yet to say which prompt it is for — is judged when it
-        // lands rather than guessed at now. This is what replaced dropping every
-        // unrelated outstanding fetch on any promote.
-        this.cache.invalidate(promptId);
-    }
-    /**
-     * Records a rollout the caller executed.
-     *
-     * Never throws and never rejects. This sits beside a user-facing request that
-     * has already been answered; telemetry that can break the thing it measures
-     * is worse than no telemetry. Failures go to `onReportError` and are dropped.
-     *
-     * Returns the rollout id it used, so a caller that wants to retry the exact
-     * same record can pass it back and land on one row.
-     */
-    async report(promptId, input) {
-        const rolloutId = input.rolloutId ?? newRolloutId();
-        if (!this.hasKey)
-            return rolloutId;
-        try {
-            await this.client.request(`/api/v1/prompts/${encodeURIComponent(promptId)}/rollouts`, { method: "POST", body: JSON.stringify({ ...input, rolloutId }) });
-        }
-        catch (err) {
-            this.onReportError?.(err);
-        }
-        return rolloutId;
-    }
-}

package/dist/prompt/codegen.d.ts

@@ -1,37 +0,0 @@
-import type { FieldSpec } from "../core/schema/types.js";
-/** The shape codegen needs from a prompt — a narrow slice of the payload. */
-export interface CodegenPrompt {
-    id: string;
-    /** The other handle `pull` and `run` accept, so it needs a key too. */
-    slug?: string | null;
-    name: string;
-    fieldSpec: FieldSpec[];
-}
-/**
- * The TypeScript type a declared field accepts.
- *
- * `enum` becomes a union of its options rather than `string`, which is the whole
- * reason a caller feels the difference: a typo in a tone or a format is caught
- * where it is written instead of at the other end of a paid request.
- */
-export declare function typeOf(field: FieldSpec): string;
-/** `{ name: type }`, or `Record<string, never>` when the prompt takes nothing. */
-export declare function valuesTypeFor(fields: FieldSpec[], indent?: string): string;
-export interface EmitOptions {
-    /** The package specifier being augmented. Overridable for tests and forks. */
-    module?: string;
-}
-/**
- * A `.d.ts` that teaches TypeScript what each stored prompt expects.
- *
- * Declaration merging rather than a generated client: the caller keeps importing
- * `Harness` from the package, and the generated file only sharpens the types it
- * already has. Nothing breaks if the file is deleted or goes stale — calls fall
- * back to `Record<string, unknown>`, and the runtime validation that always runs
- * catches what the compiler then cannot.
- *
- * `export {}` at the end is load-bearing: without it the file is a script rather
- * than a module, and `declare module` would replace the package's types instead
- * of adding to them.
- */
-export declare function emitPromptTypes(prompts: CodegenPrompt[], opts?: EmitOptions): string;

package/dist/prompt/codegen.js

@@ -1,97 +0,0 @@
-/** JSON string literal, so a quote or newline in an option cannot break the file. */
-function lit(value) {
-    return JSON.stringify(value);
-}
-/**
- * The TypeScript type a declared field accepts.
- *
- * `enum` becomes a union of its options rather than `string`, which is the whole
- * reason a caller feels the difference: a typo in a tone or a format is caught
- * where it is written instead of at the other end of a paid request.
- */
-export function typeOf(field) {
-    switch (field.type) {
-        case "number":
-            return "number";
-        case "boolean":
-            return "boolean";
-        case "enum": {
-            const options = field.options ?? [];
-            // An enum with no options declared cannot be narrowed to anything useful,
-            // and `never` would make the prompt uncallable.
-            return options.length ? options.map(lit).join(" | ") : "string";
-        }
-        case "list":
-            return "string[]";
-        case "json":
-            return "unknown";
-        default:
-            return "string";
-    }
-}
-/** A field may be omitted when it is optional or carries a default. */
-function isOptional(field) {
-    return !field.required || field.default !== undefined;
-}
-/** `{ name: type }`, or `Record<string, never>` when the prompt takes nothing. */
-export function valuesTypeFor(fields, indent = "    ") {
-    if (fields.length === 0)
-        return "Record<string, never>";
-    const lines = fields.map((f) => {
-        const doc = f.description ? `${indent}  /** ${f.description.replace(/\*\//g, "*\\/")} */\n` : "";
-        const key = /^[A-Za-z_$][\w$]*$/.test(f.name) ? f.name : lit(f.name);
-        return `${doc}${indent}  ${key}${isOptional(f) ? "?" : ""}: ${typeOf(f)};`;
-    });
-    return `{\n${lines.join("\n")}\n${indent}}`;
-}
-/**
- * A `.d.ts` that teaches TypeScript what each stored prompt expects.
- *
- * Declaration merging rather than a generated client: the caller keeps importing
- * `Harness` from the package, and the generated file only sharpens the types it
- * already has. Nothing breaks if the file is deleted or goes stale — calls fall
- * back to `Record<string, unknown>`, and the runtime validation that always runs
- * catches what the compiler then cannot.
- *
- * `export {}` at the end is load-bearing: without it the file is a script rather
- * than a module, and `declare module` would replace the package's types instead
- * of adding to them.
- */
-export function emitPromptTypes(prompts, opts = {}) {
-    // Not named `module`: the app's eslint config forbids assigning that
-    // identifier, and this package is linted under it.
-    const importFrom = opts.module ?? "@spendgraph/harness";
-    // Sorted by id so regenerating an unchanged project produces no diff.
-    const sorted = [...prompts].sort((a, b) => a.id.localeCompare(b.id));
-    const entries = sorted.map((p) => {
-        const name = p.name ? `${indentDoc(p.name)}\n` : "";
-        const values = valuesTypeFor(p.fieldSpec ?? []);
-        // A key per handle. `pull` and `run` accept an id or a slug, and the
-        // dashboard's Use-in-code tab hands out the slug — so keying on the id
-        // alone meant every snippet the product prints fell through
-        // `ValuesFor<K>` to `Record<string, unknown>` and lost the checking this
-        // file exists to provide, silently.
-        const keys = p.slug && p.slug !== p.id ? [p.id, p.slug] : [p.id];
-        return keys.map((k) => `${name}    ${lit(k)}: ${values};`).join("\n");
-    });
-    const body = entries.length
-        ? entries.join("\n")
-        : "    // No prompts found. Run `harness codegen` again after saving one.";
-    return `// Generated by \`harness codegen\`. Do not edit.
-//
-// Sharpens the id and values arguments of Harness methods. Deleting this file
-// is safe: calls fall back to a loose \`Record<string, unknown>\`, and the
-// runtime field validation is unchanged either way.
-
-declare module ${lit(importFrom)} {
-  interface Prompts {
-${body}
-  }
-}
-
-export {};
-`;
-}
-function indentDoc(text) {
-    return `    /** ${text.replace(/\*\//g, "*\\/")} */`;
-}

package/dist/prompt/render.d.ts

@@ -1,35 +0,0 @@
-export type Block = {
-    title: string;
-    body: string;
-};
-export type Message = {
-    role: "system" | "user";
-    content: string;
-};
-/**
- * Substitutes `{name}` placeholders. An unknown one is left verbatim — silently
- * emptying it would send a prompt with a hole the caller cannot see.
- *
- * Mirrors `lib/prompt.ts` in the app, deliberately duplicated: this package is
- * published and depends on nothing. The two are kept in step by
- * `rendered` being recorded on every rollout, which makes a divergence visible
- * rather than theoretical.
- */
-export declare function applyVariables(text: string, values: Record<string, string> | undefined): string;
-/** Placeholder names used anywhere in the prompt, in first-seen order. */
-export declare function findVariables(blocks: Block[], question: string): string[];
-/**
- * Blocks in the order they were arranged.
- *
- * An empty body drops the block entirely — a heading over nothing is noise in
- * the prompt. A body with no title is emitted bare rather than under a blank
- * `##`, so an unnamed block still says what it says.
- */
-export declare function compileSystemPrompt(blocks: Block[], values?: Record<string, string>): string;
-/**
- * Every message the request will send, in order.
- *
- * An empty system message is a different request from no system message at all,
- * so a prompt with no blocks sends one message rather than two.
- */
-export declare function renderMessages(blocks: Block[], question: string, values?: Record<string, string>): Message[];