@bilig/workbook 0.42.0

package/LICENSE

@@ -0,0 +1 @@
+MIT

package/README.md

@@ -0,0 +1,346 @@
+# @bilig/workbook
+
+Agent-first workbook model API and transport-neutral workbook operation language for bilig.
+
+Build `@bilig/workbook` so an agent would love using it: simple, generic,
+predictable, inspectable, verifiable, and never dependent on hardcoded business
+models or human spreadsheet UI assumptions.
+
+Use this package when a consumer needs to describe workbook work without taking a
+dependency on the engine, app server, transport, or replica-state implementation.
+
+The public surface stays generic:
+
+- `defineModel`
+- `buildWorkbookActionPlan`
+- `planWorkbookAction`
+- `inspectModel`
+- `collectWorkbookRefs`
+- `findTable`, `findColumn`, `findRange`, `findName`, `findRows`
+- `find`
+- `check`
+- `describeModel`
+- `describeRef`
+- `describePlan`
+- `describePlanResult`
+- `describeRunResult`
+- `describeRuntimeRequirements`
+- `verifyPlan`
+- `verifyModel`
+- `runWorkbookPlan`
+- `runWorkbookAction`
+- `verifyWorkbookReadbacks`
+- `normalizeWorkbookActionInputDescription`
+- `workbookPlanIssueCodes`
+- `isWorkbookPlanIssueCode`
+- `workbookReadbackIssueCodes`
+- `isWorkbookReadbackIssueCode`
+- `workbookRunErrorCodes`
+- `isWorkbookRunErrorCode`
+- `formula`
+- `workbook.addOp(op, { target?, message? })` inside model actions
+- `WorkbookModel`
+- `WorkbookAction`
+- `WorkbookActionConfig`
+- `WorkbookActionDefinition`
+- `WorkbookActionContext`
+- `WorkbookCheckContext`
+- `WorkbookFindWorkbook`
+- `WorkbookCheckWorkbook`
+- `WorkbookActionWorkbook`
+- `WorkbookModelWorkbook`
+- `WorkbookFindNamespace`
+- `WorkbookActionInput`
+- `WorkbookActionInputDescription`
+- `WorkbookActionInputDescriptionKind`
+- `WorkbookActionInspection`
+- `WorkbookAddOpOptions`
+- `WorkbookActionPlanResult`
+- `WorkbookModelDescription`
+- `WorkbookRefDescription`
+- `WorkbookActionPlanDescription`
+- `WorkbookActionPlanResultDescription`
+- `WorkbookRunResultDescription`
+- `WorkbookUndoRefDescription`
+- `WorkbookAppliedSummaryDescription`
+- `WorkbookRuntimeRequirements`
+- `WorkbookRuntimeRequirement`
+- `WorkbookRuntimeCapability`
+- `WorkbookRuntimeMaterialization`
+- `WorkbookRuntimePreview`
+- `WorkbookPlanVerification`
+- `WorkbookPlanIssue`
+- `WorkbookPlanIssueCode`
+- `WorkbookModelVerification`
+- `WorkbookModelActionVerification`
+- `WorkbookModelVerificationOptions`
+- `WorkbookRunAdapter`
+- `WorkbookRunApplyResult`
+- `WorkbookCellReadback`
+- `WorkbookRunReadback`
+- `WorkbookReadbackVerification`
+- `WorkbookReadbackIssue`
+- `WorkbookReadbackIssueCode`
+- `WorkbookCheckExpectation`
+- `WorkbookCheckExpectationDescription`
+- `WorkbookCustomCheckOptions`
+- `WorkbookReadbackCheckOptions`
+- `WorkbookRawFormulaOptions`
+- `WorkbookRunResult`
+- `WorkbookAppliedSummary`
+- `WorkbookRunError`
+- `WorkbookRunErrorCode`
+- `WorkbookCheckResult`
+
+The low-level operation language remains available:
+
+- `WorkbookOp`
+- `WorkbookTxn`
+- `EngineOp`
+- `EngineOpBatch`
+- `isEngineOpBatch`
+
+Formula helpers create portable formula expressions with `@bilig/formula`.
+Calculation and workbook execution stay in `@bilig/core` and the app runtime.
+Use `planWorkbookAction` when an action name comes from an agent or user input;
+it returns `planned` or structured `failed` results instead of requiring
+exception control flow.
+Actions can also accept a JSON-safe input:
+
+```ts
+import { defineModel } from '@bilig/workbook'
+
+export const model = defineModel({
+  name: 'custom-writer',
+
+  find(workbook) {
+    return {
+      output: workbook.findRange({ sheetName: 'Sheet1', address: 'B2' }),
+    }
+  },
+
+  actions: {
+    write({ refs, workbook, input }) {
+      if (typeof input !== 'object' || input === null || Array.isArray(input)) {
+        throw new Error('input object required')
+      }
+      const value = input.value
+      if (typeof value !== 'number') {
+        throw new Error('numeric value required')
+      }
+      workbook.writeValue(refs.output, value)
+    },
+  },
+})
+```
+
+`planWorkbookAction(model, "write", { value: 12 })` clones and canonicalizes
+that input into the plan so an agent can inspect exactly what was requested.
+Inputs must be plain JSON values: strings, finite numbers, booleans, `null`,
+arrays without holes, and plain objects. When an action object declares input
+metadata, `planWorkbookAction` validates the provided value against the declared
+JSON kind, required fields, and array item kind before `find`, `checks`, or the
+action body run. This stays intentionally small: it is a dependency-free guard
+for agent handoff, not a model-specific schema framework.
+Use `verifyModel(model, { inputs: { write: { value: 12 } } })` when whole-model
+verification needs parameters for specific actions.
+
+Actions can also be plain action objects when an agent needs a richer manifest
+without running workbook code:
+
+```ts
+actions: {
+  write: {
+    description: 'Write a consumer-provided value',
+    input: {
+      kind: 'object',
+      fields: {
+        value: { kind: 'number', required: true },
+      },
+    },
+    run({ refs, workbook, input }) {
+      if (typeof input !== 'object' || input === null || Array.isArray(input)) {
+        throw new Error('input object required')
+      }
+      const value = input.value
+      if (typeof value !== 'number') {
+        throw new Error('numeric value required')
+      }
+      workbook.writeValue(refs.output, value)
+    },
+  },
+}
+```
+
+Input descriptions support boring JSON kinds: `json`, `object`, `array`,
+`string`, `number`, `boolean`, and `null`. `object` descriptions may list sorted
+`fields`; `array` descriptions may list `items`; any description may be marked
+`required`. `normalizeWorkbookActionInputDescription` trims text, rejects
+malformed metadata, returns frozen data, and keeps the package free of `zod`,
+`effect`, or model-specific validators.
+
+Formula expressions also keep their workbook inputs separate from their formula
+text. A planned `writeFormula` command includes both the parseable formula
+string and the generic model refs it used, so an agent can inspect what the
+action depends on without reverse-parsing placeholder names.
+For formulas outside the small helper set, use
+`formula.raw(source, { inputs })`; the source stays parseable while the
+declared refs remain inspectable and verifiable. These inputs are a declared
+dependency contract for agents, not parser-discovered proof that every formula
+reference has been mapped to a model ref.
+
+Known single-cell `workbook.format(ref, { numberFormat })` actions compile to
+concrete `setCellFormat` ops. Use `numberFormat: null` to plan an explicit
+format clear. Style patches remain high-level intent until the runtime resolves
+style ids.
+Use `workbook.addOp(op, { target?, message? })` inside model actions when a
+consumer needs the existing low-level workbook operation language directly. The
+op is runtime-guarded with `isWorkbookOp`, cloned into `plan.ops`, and kept in
+the command log so agents can inspect it without depending on `@bilig/core`.
+When a `target` is supplied for an address or range op, `verifyPlan` checks that
+the op touches the same range. For op kinds without an inferable range, `target`
+is still useful for logs and approvals but cannot prove the affected cells by
+itself.
+
+Action plans expose `refsUsed`, a flat deduped list of workbook refs found in
+the consumer-defined `refs` object. Use `collectWorkbookRefs` directly when an
+agent needs to inspect refs from any nested consumer shape.
+Use `findTable`, `findColumn`, `findRange`, `findName`, and `findRows` directly
+when an agent or test needs the same generic refs outside a model callback. The
+same helpers are also available as a frozen `find` namespace with short aliases
+such as `find.table(...)`, `find.range(...)`, and `find.rows(...)`.
+Selector helpers trim text, canonicalize cell addresses, and reject empty table
+names, column names, named ranges, headers, invalid range addresses, invalid row
+operators, and non-finite row predicate values before a plan reaches runtime.
+`findRows` refs include the predicate value in their stable id so two
+consumer-defined row selectors do not collapse during dedupe, while labels stay
+human-readable for agent logs.
+Refs are frozen data objects. Ergonomic helpers like `table.column()` and
+`rows.column()` remain available, but they are non-enumerable so JSON
+inspection, object keys, and plan descriptions stay data-first.
+For table-backed rows, use `rows.column("Amount")` to target only that column in
+the matching rows. Runtime adapters can materialize row-filtered columns into
+the exact cells to read, write, format, clear, or use as row-wise formula inputs
+without hardcoding a business model.
+Use `check.exists(ref)` and `check.noFormulaErrors(ref)` directly when an agent
+or test needs the same generic planned checks outside a model callback.
+Use `check.valueEquals(ref, value)` and `check.formulaEquals(ref, formula)` for
+single-cell readback expectations. Use `check.valuesEqual(ref, rows)` and
+`check.formulasEqual(ref, rows)` when the target may resolve to a range, table
+column, or row-filtered column. `formulaEquals` stores normalized formula text
+plus explicit model refs used by that formula, so an agent can inspect the
+post-action proof target without depending on a rendered spreadsheet UI.
+Use `check.custom({ kind, message, target, refs })` for consumer-defined
+invariants; the package does not need to know what the model means. `target`
+names the main ref, and `refs` names any supporting refs the invariant depends
+on so agents can describe and verify the full check contract.
+
+Model callback phases are deliberately scoped. `find(workbook)` receives only
+the find API; `checks({ workbook })` receives find helpers plus `workbook.check`;
+actions receive find helpers, checks, and mutation planning methods. That keeps
+discovery and proof declaration separate from workbook mutation intent.
+
+Use `describeModel` when an agent needs a JSON-safe manifest of model name,
+model description, sorted action names, per-action descriptions, optional input
+descriptions, and whether model-level checks exist without running `find`,
+checks, or actions.
+Use `describeRef` and `describePlan` when an agent needs JSON-safe intent for
+logs, comparisons, approvals, or runtime handoff. Descriptions keep the same
+generic action input, refs, commands, checks, changes, and ops, but omit
+consumer-private `refs` object shape and helper functions such as
+`table.column()`.
+Use `describePlanResult` when the same JSON-safe handoff is needed for either
+planned or failed action planning.
+Use `describeRunResult` after execution when an agent needs the same JSON-safe
+shape for `done` or `failed` run results. It preserves changed summaries,
+checks, errors, and undo ops, but describes workbook refs without helper
+functions such as `table.column()` or `rows.column()`.
+Run errors use a stable `WorkbookRunErrorCode` union rather than arbitrary
+strings. Use the frozen `workbookRunErrorCodes` list and `isWorkbookRunErrorCode`
+guard when an adapter, logger, or approval layer needs to branch on known
+failure classes. Runtime adapters should use `apply_failed` for apply
+exceptions and `runtime_rejected` for intentional runtime refusal with a
+specific message instead of inventing new public codes.
+Planning and readback failures expose the same kind of boring machine contract:
+use `workbookPlanIssueCodes` with `isWorkbookPlanIssueCode`, and
+`workbookReadbackIssueCodes` with `isWorkbookReadbackIssueCode`, when an agent
+needs to branch before or after runtime handoff without guessing string values.
+Use `describeRuntimeRequirements(plan)` before runtime handoff when an agent
+needs to inspect what the adapter must do. It returns a JSON-safe list of
+generic `apply`, `read`, and `verify` requirements with boring capabilities
+such as `writeFormula`, `writeValue`, `format`, `clear`, `applyOp`, `read`, and
+`verifyCheck`. Apply requirements also say whether the command is already backed
+by a concrete op, is a provided low-level op, or needs runtime materialization.
+Every requirement has a stable `path` such as `commands[0]`, `checks[2]`, or
+`ops[1]`; read requirements include the machine-readable expectation. It does
+not execute anything and it does not import the engine.
+
+Use `verifyPlan` before runtime handoff when an agent needs to prove a planned
+action is internally consistent. It checks for non-JSON-safe action input,
+unresolved refs, unparsable formulas, duplicate resolved refs, and missing
+concrete ops for write, clear, and number-format commands that already target a
+known single cell. Custom check targets and supporting refs must also resolve
+through the model's `refsUsed` contract. Formula readback expectation inputs
+must also resolve through `refsUsed`, and expectation formulas must be parseable.
+Checks must start as `planned`; consumer code cannot mark a check passed or
+failed before runtime proof.
+Low-level `addOp` commands must contain valid `WorkbookOp` values, must still
+appear in `plan.ops`, and must match their declared `target` when the op exposes
+a concrete address or range.
+Use `verifyModel` to plan and verify every action in a consumer-defined model
+with one JSON-safe result. Pass `inputs` when specific actions require
+parameters.
+
+Use `runWorkbookPlan(plan, adapter)` or
+`runWorkbookAction(model, actionName, adapter, input)` when an agent needs a
+generic apply-and-prove loop. The adapter owns runtime execution and semantic
+readback:
+
+```ts
+const result = await runWorkbookAction(model, 'write', {
+  apply(plan) {
+    return runtime.apply(plan.ops)
+  },
+  read(targets) {
+    return runtime.read(targets)
+  },
+})
+```
+
+`runWorkbookAction` plans the action, runs `verifyPlan`, calls
+optional `adapter.preview(plan)`, calls `adapter.apply(plan)`, then evaluates
+`valueEquals`, `valuesEqual`, `formulaEquals`, and `formulasEqual` checks
+against `adapter.read(targets, plan)`.
+It never imports the engine, headless runtime, app server, or UI. If static
+verification fails, the apply adapter is not called. If preview is available,
+successful results include an `applied` summary with the materialized op count
+and ops that the adapter preview produced. If a readback expectation is missing,
+duplicated, or mismatched, the returned `WorkbookRunResult` is `failed` with
+deterministic error codes such as `readback_missing`, `duplicate_readback`,
+`value_mismatch`, `values_mismatch`, `formula_mismatch`, or
+`formulas_mismatch`; errors preserve structured `path`, `target`, `check`,
+`expected`, and `actual` fields where available.
+Runtime outputs are validated too: malformed preview, apply, or readback
+payloads fail as `invalid_runtime_result` instead of being treated as proof.
+Formula readbacks are exact: adapters should return formula text in the same
+normalized no-leading-`=` form produced by `formula.source`.
+`adapter.apply` only applies the plan and may return an undo ref; it cannot
+drop, replace, or prove checks.
+Adapters provide `verifyChecks(checks, plan)` to prove non-readback checks such
+as `exists`, `noFormulaErrors`, and consumer-defined `custom` invariants. The
+verifier must return the same checks in the same order and may only change
+`status`; changing `kind`, `target`, `refs`, `expectation`, or `message` fails
+the run as `invalid_check_verification`. If any verified check is `failed`, the
+run returns `failed` with `check_failed`. If any check remains `planned` after
+readback and adapter verification, the run returns `failed` with
+`check_not_verified`; `status: "done"` means every planned check has proof.
+
+When running against Bilig's engine, use `createWorkbookRunAdapter(engine)` from
+`@bilig/core`. The adapter materializes generic `plan.commands` into engine
+operations, previews the exact materialized ops, applies additional `plan.ops`
+that are not already represented by materialized commands, reads single-cell and
+multi-cell expectation targets, and verifies generic `exists` and
+`noFormulaErrors` checks
+without adding workbook-specific business models to this package. If the engine
+captures undo, the run result includes `undo.ops` in the same portable
+operation language.

package/dist/check.d.ts

@@ -0,0 +1,26 @@
+import { type LiteralInput } from '@bilig/protocol';
+import type { WorkbookRef } from './find.js';
+import { type WorkbookFormulaOperand } from './formula.js';
+import type { WorkbookCheckResult } from './result.js';
+export interface WorkbookCustomCheckOptions {
+    readonly kind: string;
+    readonly message: string;
+    readonly target?: WorkbookRef;
+    readonly refs?: readonly WorkbookRef[];
+}
+export interface WorkbookReadbackCheckOptions {
+    readonly message?: string;
+}
+export interface WorkbookCheckApi {
+    readonly exists: (target: WorkbookRef) => WorkbookCheckResult;
+    readonly noFormulaErrors: (target: WorkbookRef) => WorkbookCheckResult;
+    readonly valueEquals: (target: WorkbookRef, value: LiteralInput, options?: WorkbookReadbackCheckOptions) => WorkbookCheckResult;
+    readonly valuesEqual: (target: WorkbookRef, values: readonly (readonly LiteralInput[])[], options?: WorkbookReadbackCheckOptions) => WorkbookCheckResult;
+    readonly formulaEquals: (target: WorkbookRef, value: WorkbookFormulaOperand, options?: WorkbookReadbackCheckOptions) => WorkbookCheckResult;
+    readonly formulasEqual: (target: WorkbookRef, formulas: readonly (readonly (string | null)[])[], options?: WorkbookReadbackCheckOptions) => WorkbookCheckResult;
+    readonly custom: (options: WorkbookCustomCheckOptions) => WorkbookCheckResult;
+}
+export declare function createWorkbookCheckResult(kind: string, target: WorkbookRef, message: string): WorkbookCheckResult;
+export declare function createWorkbookCustomCheck(options: WorkbookCustomCheckOptions): WorkbookCheckResult;
+export declare function createWorkbookCheckApi(record?: (check: WorkbookCheckResult) => void): WorkbookCheckApi;
+export declare const check: WorkbookCheckApi;

package/dist/check.js

@@ -0,0 +1,158 @@
+import { isLiteralInput } from '@bilig/protocol';
+import { formula } from './formula.js';
+export function createWorkbookCheckResult(kind, target, message) {
+    return createWorkbookCustomCheck({ kind, target, message });
+}
+function requiredText(value, name) {
+    const trimmed = value.trim();
+    if (trimmed === '') {
+        throw new Error(`Workbook check ${name} cannot be empty`);
+    }
+    return trimmed;
+}
+function checkedLiteralInput(value) {
+    if (!isLiteralInput(value)) {
+        throw new Error('Workbook readback value must be a finite JSON literal');
+    }
+    return value;
+}
+function checkedLiteralMatrix(values) {
+    if (!Array.isArray(values)) {
+        throw new Error('Workbook readback values must be an array of rows');
+    }
+    let width;
+    return Object.freeze(values.map((row, rowIndex) => {
+        if (!Array.isArray(row)) {
+            throw new Error(`Workbook readback values row ${rowIndex.toString()} must be an array`);
+        }
+        width ??= row.length;
+        if (row.length !== width) {
+            throw new Error('Workbook readback values must be rectangular');
+        }
+        return Object.freeze(row.map(checkedLiteralInput));
+    }));
+}
+function checkedFormulaMatrix(formulas) {
+    if (!Array.isArray(formulas)) {
+        throw new Error('Workbook readback formulas must be an array of rows');
+    }
+    let width;
+    return Object.freeze(formulas.map((row, rowIndex) => {
+        if (!Array.isArray(row)) {
+            throw new Error(`Workbook readback formulas row ${rowIndex.toString()} must be an array`);
+        }
+        width ??= row.length;
+        if (row.length !== width) {
+            throw new Error('Workbook readback formulas must be rectangular');
+        }
+        return Object.freeze(row.map((formulaText) => {
+            if (formulaText !== null && typeof formulaText !== 'string') {
+                throw new Error('Workbook readback formula must be a string or null');
+            }
+            return formulaText;
+        }));
+    }));
+}
+function refKey(ref) {
+    return `${ref.kind}:${ref.id}`;
+}
+function uniqueRefs(refs) {
+    if (refs === undefined) {
+        return undefined;
+    }
+    const seen = new Set();
+    const unique = [];
+    for (const ref of refs) {
+        const key = refKey(ref);
+        if (seen.has(key)) {
+            continue;
+        }
+        seen.add(key);
+        unique.push(ref);
+    }
+    return unique.length === 0 ? undefined : unique;
+}
+function createWorkbookCheck(options) {
+    const refs = uniqueRefs(options.refs);
+    return {
+        status: 'planned',
+        kind: requiredText(options.kind, 'kind'),
+        ...(options.target !== undefined ? { target: options.target } : {}),
+        ...(refs !== undefined ? { refs } : {}),
+        message: requiredText(options.message, 'message'),
+        ...(options.expectation !== undefined ? { expectation: options.expectation } : {}),
+    };
+}
+export function createWorkbookCustomCheck(options) {
+    return createWorkbookCheck(options);
+}
+export function createWorkbookCheckApi(record) {
+    function planned(options) {
+        const check = createWorkbookCheck(options);
+        record?.(check);
+        return check;
+    }
+    return {
+        exists(target) {
+            return planned({ kind: 'exists', target, message: `${target.label} exists` });
+        },
+        noFormulaErrors(target) {
+            return planned({ kind: 'noFormulaErrors', target, message: `${target.label} has no formula errors` });
+        },
+        valueEquals(target, value, options = {}) {
+            const expected = checkedLiteralInput(value);
+            return planned({
+                kind: 'valueEquals',
+                target,
+                message: options.message ?? `${target.label} equals ${JSON.stringify(expected)}`,
+                expectation: {
+                    kind: 'valueEquals',
+                    value: expected,
+                },
+            });
+        },
+        valuesEqual(target, values, options = {}) {
+            const expected = checkedLiteralMatrix(values);
+            return planned({
+                kind: 'valuesEqual',
+                target,
+                message: options.message ?? `${target.label} values equal ${JSON.stringify(expected)}`,
+                expectation: {
+                    kind: 'valuesEqual',
+                    values: expected,
+                },
+            });
+        },
+        formulaEquals(target, value, options = {}) {
+            const source = formula.source(value);
+            const inputs = formula.inputs(value);
+            return planned({
+                kind: 'formulaEquals',
+                target,
+                message: options.message ?? `${target.label} formula equals ${source}`,
+                expectation: {
+                    kind: 'formulaEquals',
+                    formula: source,
+                    inputs,
+                },
+            });
+        },
+        formulasEqual(target, formulas, options = {}) {
+            const expected = checkedFormulaMatrix(formulas);
+            return planned({
+                kind: 'formulasEqual',
+                target,
+                message: options.message ?? `${target.label} formulas equal ${JSON.stringify(expected)}`,
+                expectation: {
+                    kind: 'formulasEqual',
+                    formulas: expected,
+                },
+            });
+        },
+        custom(options) {
+            return planned(options);
+        },
+    };
+}
+export const check = createWorkbookCheckApi();
+//# sourceMappingURL=check.js.map

package/dist/check.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"check.js","sourceRoot":"","sources":["../src/check.ts"],"names":[],"mappings":"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"}