@peripheries/renderer 0.22.0 → 0.23.1

package/README.md

@@ -1,18 +1,18 @@
 # @peripheries/renderer
 
-The one renderer for pages built from federated component bundles
-([design/renderer.md](../../docs/plan/design/renderer.md)). The host, the
-component repos' harness and the agency's preview all render through it, so a
-page looks the same in each.
+The one renderer for pages built from federated component bundles. Hosts,
+component repos' harnesses and previews all render through it, so a page looks
+the same in each.
 
 | Entry | Holds |
 |---|---|
 | `@peripheries/renderer/core` | Framework-free: cells and thin-ref hydration, references and conditions, the data context, walks and state names, cell props, layout, document structure, bundle refs and resolution, the shared store, `loadPageData(page, source)`, validation, `DIAGNOSTICS` and `PAGE_RULES` |
-| `@peripheries/renderer/catalog` | `checkCatalog`: what a component repo runs on the knowledge it emits (design/catalog.md §5). The only entry with a JSON Schema validator (ajv) |
-| `@peripheries/renderer/react` | `PageRenderer`, `CellView`, `StructureView`, the cell states, `useContainerSize` |
+| `@peripheries/renderer/catalog` | `checkCatalog`: what a component repo runs on the knowledge it emits. The only entry with a JSON Schema validator (ajv) |
+| `@peripheries/renderer/react` | `PageRenderer`, `CellView`, `StructureView`, the cell states, `useContainerSize`, `useFormsRuntime` and its `FormSlotProps` and `FormAnswer` |
 | `@peripheries/renderer/runtime` | What a page boots with: the import map and boot script, the shims, `installRuntime`, the store bundles import |
-| `@peripheries/renderer/theme` | The org theme pipeline (design/core-and-tokens.md §6.2): `parseTheme` (version 1 or 2 in, version 2 out, with diagnostics), `themeTokens` (semantic overrides derived in OKLCH), `themeCss` (the `theme` layer), `checkTheme` (WCAG contrast) |
+| `@peripheries/renderer/theme` | The org theme pipeline: `parseTheme` (version 1 or 2 in, version 2 out, with diagnostics), `themeTokens` (semantic overrides derived in OKLCH), `themeCss` (the `theme` layer), `checkTheme` (WCAG contrast) |
 | `@peripheries/renderer/print` | The print pipeline, framework-free: `collectBlocks` (the page map), `paginate`, `buildPrintLayout` (the packer's decision as CSS), `buildPageStylesheet` (`@page` geometry and margin boxes), running headers, `@printPolicy` parsing, print lint, `resolveDocumentProfile`, region bindings, map staleness, and the `layout.structure[].print` writer |
+| `@peripheries/renderer/forms` | The forms runtime, framework-free: the steps overlay and its model, conditions, modes, navigation, progress, deep links, and the persistence port (`FormsPort`); the React hook is `useFormsRuntime` in `/react` |
 | `@peripheries/renderer/testing` | The golden pages, synthetic fixtures, and sources that serve them |
 | `@peripheries/renderer/styles.css` | Page and cell containers, the responsive buckets, placeholders and notices, in the `renderer` layer |
 
@@ -32,9 +32,18 @@ const runtime = await loadPageData(page, source, { params, baseProps, viewer, co
 
 `RendererEnvironment` takes, besides `core`, `navigate` and `store`:
 
-- `actionsFor(cell)`: the actions a cell gets. The host has none until R2's
-  write rule; `projectCellActions(cell.actions, pageActions)` applies the PWA's
-  lookup rule (binding key, then registry key, then the cell's own name).
+- `actionsFor(cell)`: the actions a cell gets;
+  `projectCellActions(cell.actions, pageActions)` applies the lookup rule
+  (binding key, then registry key, then the cell's own name).
+- `runAction`: runs a cell's declared action (the host's write path, or a
+  harness's mock); without it a declared action reports `FAILED`.
+- `loadPage`: loads a paged label's next page.
+- `onPropSources(cell, sources)`: each rendered cell's props, leaf by leaf,
+  with where each value came from (for an edit layer, with `editTarget`).
+- `retry()`: reads the page again, for a failed cell's "Try again".
+- `cellProps(cell)`: props from the page's runtime, merged last; on a form
+  page, `useFormsRuntime`'s `cellProps` gives each cell `form`, `answers` and
+  `answer`.
 - `onCellError(cellId, error)`: a component threw. The cell shows an error
   notice either way.
 - `onUnresolvedReference(cellId, ref)`: a prop's `@ref` resolved to nothing
@@ -52,8 +61,7 @@ sharing the channel reads it.
 ## The names a bundle may rely on
 
 What the renderer writes, for a bundle's CSS and checks. These are the only
-names: 0.8.0 dropped the old client-prefixed twins and container names
-(design/core-and-tokens.md §14).
+names: 0.8.0 dropped the old client-prefixed twins and container names.
 
 | Where | Name |
 |---|---|
@@ -69,7 +77,102 @@ bundle's `ThemeProvider` export.
 
 ## Versions
 
-- **0.10.0** (data-render M2): actions run, documents edit, pages embed.
+- **0.23.1** (2026-10-15): the published files carry no comments and no
+  source maps (declarations included); this README is the documentation.
+  No API change.
+
+- **0.23.0** (2026-10-15): the
+  versions and forms release, in one minor.
+  - **Main only:** `prepareDocument` reads
+    main systems and placements only, adding `version: { is: NULL }` to
+    `systemCollection`, `graph_nodeCollection` and `graph_edgeCollection`
+    at any depth. New diagnostics: `SYSTEM_NOT_MAIN` (a warning: a page
+    names a system that isn't main, read as absent; `GraphSource.mainSystems`
+    says which are), `DESCRIPTOR_VERSION_FILTER` (a document filters on
+    `version` itself) and `DESCRIPTOR_STATE_UNSCOPED` (a document reads
+    states by node or unfiltered, so a branch's would be read too); both are
+    refused before a document is sent.
+  - **The version context:** `PageScope.version` (`VersionContext {
+    versionId, versionKind }`, from `@peripheries/runtime`) reaches every
+    `GraphSource` read as an optional trailing `ReadContext`, and
+    `@context.version` / `@context.versionKind` name it to a query. At main
+    the reads are 0.22's. The runtime freezes the read-side types
+    (`ResolvedVersionContext`, `StateAsOf`, `NodeStateView`, `Via`,
+    `ReleaseProblem`, `RecordedEmbed`).
+  - **Edits at a version:** a release or a channel refuses an edit before
+    it is sent (`VERSION_IS_RELEASE`); a branch's edit carries
+    `p_version_id`.
+  - **Embeds and print at a version:** `PageScope.recordedEmbeds` (a
+    release's `metadata.embeds`) makes an embed render the release its host
+    recorded, else the viewer's context; `PageRuntime.embedVersion` says
+    which (`recorded` | `context`), and `PageRuntime.readVersionIds` the
+    versions the states were read from, for print's and an embed's "Release
+    N". A state row may carry `versionId`, `unversioned` and `outOfScope`.
+  - **Render-time functions:** `RENDER_FUNCTIONS` adds the version reads
+    (`node_states_as_of`, `node_state_view`, `version_context_for`,
+    `version_scope_members`, `versions_for`, `version_diff`,
+    `auto_release_status`), each with the tables it reads for
+    invalidation.
+  - **Declared ahead:** `form_answers(p_structure_nodes: [UUID!]!)` is a
+    render function now, listed in `RENDER_FUNCTIONS_AHEAD` until the
+    database has it, so descriptors can read a workbook's answers without a
+    renderer release. Its JSON is a leaf:
+    `result.path` reads into it and nothing in it is flattened. An alias on
+    a render function's JSON root is refused (`DESCRIPTOR_ALIAS_JSON_ROOT`),
+    since its JSON is decoded by field name.
+  - **Systems from the graph:** `GraphSource.graphSystems(processId)` (the
+    main, keyless systems on the process's graphs, with each graph's type
+    and layer's role) is how `resolveSystems` finds a page's systems;
+    `processSystems` is optional and read only without it, and
+    `metadata.pageProcess` is no longer read. A state name is `<tier>_<role>`
+    for any registered layer's role (`eng_answer`), not only the four;
+    whether the page's process has it is `STATE_UNKNOWN_SYSTEM` at load.
+  - **Releases:** `validateManifest(pages)` returns `ReleaseProblem[]`,
+    advisory before a release; `manifestPageFrom(graphNodeId, data)` reads a
+    page artifact's state data as a manifest page. The runtime adds `PageView` and
+    `SubmissionData`.
+  - **The forms runtime** (`@peripheries/renderer/forms`): the steps
+    overlay, modes, navigation, saving, progress and deep links behind
+    `FormsPort { save, submit, visit, reopen }` (and, optional, `upload` and
+    `openFile` for file answers), with `useFormsRuntime` and `FormSlotProps`
+    in `/react`. Refusals are codes, never throws (`FormsRefusal`:
+    `CONFLICT`, `ANSWER_*`, `FORM_INCOMPLETE`, `FORM_NOT_OPEN`,
+    `FORM_COMPLETED`, `FORM_STEP_UNKNOWN`, `NO_CAPABILITY`, `NETWORK`).
+    `reopen` is the "Edit answers" slot on a submitted form. A phone opens
+    in question mode; the slot props carry the question shown (`question`,
+    its place and the next), `goToQuestion`, `progress.total` beside the
+    required count, a step's authored `label`, and stay one object while
+    what they show is unchanged. A step with only optional questions is
+    complete once seen. The slot props name every chapter, the submission's
+    `status`, `readOnly`, and the newest staff `review` (its note, status,
+    time and writer). The runtime adds `FileAnswer` and `AnswerValue`;
+    `SubmissionData` carries `reopens` and each note's `status`.
+  - **Form cells:** on a form page each cell gets, through
+    `RendererEnvironment.cellProps` (useFormsRuntime's `cellProps`), `form`
+    (the slot props), `answers` (its questions the conditions show, by key)
+    and, with one question, `answer`: a `FormAnswer { key, label, question,
+    value, change, readOnly, required, missing, refusal, inputId, upload?,
+    openFile? }`, in the slot props' words. `question` is the question's
+    definition (`FormQuestion.definition`); `inputId` is where
+    `goToQuestion` moves focus. In question mode `FormSlotProps.question`
+    carries the same `answer`.
+  - **For consumers** (nothing is required to keep 0.22's behaviour):
+    - a `GraphSource` adds `graphSystems(processId)` to find systems by
+      graph (else `processSystems` is read), `mainSystems(ids)` to read
+      main only (else every system is read), and takes the trailing
+      `ReadContext` to read at a version (else it reads main);
+    - a host passes `PageScope.version` (and `recordedEmbeds` at a release)
+      to read at a version, and refuses nothing else itself;
+    - a form host implements `FormsPort` (`upload` and `openFile` only if
+      it takes files) and passes `cellProps` from `useFormsRuntime` as
+      `RendererEnvironment.cellProps`; `review.by` is a display name or
+      null, never an email or a user id;
+    - a component reads `form`, `answers` and `answer` from its props on a
+      form page, and puts `answer.inputId` on its control.
+    - page ids (an embed's `page_id`, `PageScope`'s page) become anchor
+      ids; the renderer treats them as opaque, so nothing changes.
+
+- **0.10.0:** actions run, documents edit, pages embed.
   - Declared actions run through the environment's `runAction`; the runtime's
     `ACTION_FIELDS` takes `subjects` and `audience` on `create`, `edit` and
     `append`, and `create` needs `edge_type` only under a parent.
@@ -85,9 +188,8 @@ bundle's `ThemeProvider` export.
   - A nullable query variable whose whole reference reads `@params`,
     `@context` or `@viewer` and resolves to nothing is sent as `null`.
   - PAGE_RULES is shorter (3780 characters) and describes embed cells.
-- **0.9.0** (data-render M1; prerelease `0.9.0-data-render.0`): queries
-  (design/data.md §2–§6), realtime's inputs, the host contract retired, and
-  the renderer half of actions (§9.2).
+- **0.9.0:** queries, realtime's inputs, the host contract retired, and
+  the renderer half of actions.
   - A label can be `{ descriptor: QueryDescriptor }`, or a node binding to a
     live `query_data` node, whose descriptor runs instead of returning its
     state. `GraphSource` gains `query(descriptor, variables)`, which returns
@@ -118,7 +220,7 @@ bundle's `ThemeProvider` export.
 
 - **0.8.1:** `BaseProps` carries the org's `locale` and `currency` (from its
   org template's metadata), which `@stack/charts` formats with.
-- **0.8.0:** the old names go (design/core-and-tokens.md §14). The renderer
+- **0.8.0:** the old names go. The renderer
   writes only the attributes and container names above, the runtime installs
   only `__STACK_RUNTIME__` and maps only `@stack/store`, and the store has no
   second hook name. A bundle's `ThemeProvider` is no longer lifted or wrapped
@@ -126,15 +228,15 @@ bundle's `ThemeProvider` export.
   gone). `@peripheries/runtime` 0.8.0 drops `LEGACY_RUNTIME_GLOBAL` and
   `SPECIFIER_ALIASES`.
 
-- **0.7.3:** the page container also carries `data-page-grid`, the name
-  design/bundles.md §6 gives the old page-grid attribute, so every attribute
+- **0.7.3:** the page container also carries `data-page-grid`, the
+  canonical name of the old page-grid attribute, so every attribute
   the renderer writes has its canonical name (above) before the old ones go.
 
 - **0.7.2:** the package ships its LICENSE: proprietary to Peripheries Studio
   Inc., all rights reserved.
 - **0.7.1:** `bundleScope` puts the advisor org's `main` after the shared
   lineages, so an advisor org's older copy of a core component never shadows
-  core on a client org's page (design/core-and-tokens.md §3).
+  core on a client org's page.
 - **0.7.0:** shared lineages and the theme. `bundleScope` appends the
   platform's shared lineages, and the loader imports them by specifier;
   `@core/` resolves from `stack/core` (`host:` is retired); `importMapFor` and
@@ -174,7 +276,7 @@ bundle's `ThemeProvider` export.
 - **0.3.0:** `@peripheries/runtime/rank`, sibling order on `graph_node.rank`
   (`compareRank`, `sortByRank`, `rankBetween` and the rest), so no one
   vendors it; the `WALK_NODE_TYPES_EMPTY` warning, because `nodeTypes: []`
-  filters nothing here where the PWA read it as "enter nothing".
+  filters nothing (it doesn't mean "enter nothing").
 - **0.2.0:** the hooks above, `pageRuntimeFromValues`, action projection,
   `data-missing-component` on a missing component's notice, the theme passed
   to `ThemeProvider`, store defaults seeded.
@@ -195,7 +297,7 @@ to fix it; `Diagnostic.code` is typed from that table. Tools show the fix with
 the diagnostic, so a writer learns a rule when they break it.
 
 **`PAGE_RULES`** (from `/core`) is the host's rules for composing a page, the
-short text a writer reads first (design/catalog.md §3.3). It is built from the
+short text a writer reads first. It is built from the
 constants the renderer and validator use, so it changes when they do.
 
 `core` imports no React at runtime and never reaches the network, and the
@@ -206,4 +308,4 @@ code; the golden pages run over fixture sources in `react/golden-pages.test.tsx`
 publishes every package whose version isn't on npm yet, built output only;
 `.github/workflows/publish-packages.yml` stages each new version from
 `develop`, and a maintainer approves it on npmjs.com. Bump the version here to
-release (design/renderer.md §11).
+release.

package/dist/catalog.js

@@ -1,8 +1,7 @@
-import { b as isEach } from "./chunks/query-BPuCJC1C.js";
-import { i as eachFormProblems, s as validatePage } from "./chunks/validate-4LgH8QMJ.js";
+import { x as isEach } from "./chunks/query-D6xQbTFK.js";
+import { i as eachFormProblems, s as validatePage } from "./chunks/validate-BcB_PA1k.js";
 import { KNOWLEDGE_BUDGETS, KNOWLEDGE_KEY } from "@peripheries/runtime";
 import Ajv2020 from "ajv/dist/2020.js";
-//#region packages/renderer/src/catalog/check.ts
 var ref = (kind, key) => `${kind}:${key}`;
 var size = (v) => JSON.stringify(v ?? null).length;
 var isReference = (v) => typeof v === "string" && (v.startsWith("@") || v.includes("${"));
@@ -272,7 +271,4 @@ function validateLiteral(schema, value, path, push, ajv) {
 		if (!ajv.validate(schema, value)) push("error", "PROP_INVALID", path, ajv.errorsText(ajv.errors, { dataVar: "" }).replace(/^\s+/, ""));
 	} catch {}
 }
-//#endregion
 export { checkCatalog, validatePageProps };
-
-//# sourceMappingURL=catalog.js.map

package/dist/chunks/forms-DxA9WzCt.js

@@ -0,0 +1,336 @@
+var CONDITION_OPS = [
+	"eq",
+	"ne",
+	"in",
+	"not_in",
+	"gt",
+	"lt",
+	"gte",
+	"lte",
+	"contains",
+	"not_contains",
+	"empty",
+	"not_empty"
+];
+var OPS = new Set(CONDITION_OPS);
+function isConditionOp(op) {
+	return typeof op === "string" && OPS.has(op);
+}
+function isBlank(value) {
+	if (value === null || value === void 0) return true;
+	if (typeof value === "string") return value.trim() === "";
+	if (Array.isArray(value)) return value.length === 0;
+	return false;
+}
+function asNumber(value) {
+	if (typeof value === "number") return value;
+	const n = Number.parseFloat(String(value));
+	return Number.isFinite(n) ? n : NaN;
+}
+function looseEquals(a, b) {
+	if (a === b) return true;
+	if (a === null || a === void 0 || b === null || b === void 0) return false;
+	return String(a) === String(b);
+}
+function anyOverlap(actual, expected) {
+	const list = Array.isArray(expected) ? expected : [expected];
+	if (Array.isArray(actual)) return actual.some((a) => list.some((e) => looseEquals(a, e)));
+	return list.some((e) => looseEquals(actual, e));
+}
+function contains(actual, expected) {
+	if (Array.isArray(actual)) return actual.some((a) => looseEquals(a, expected));
+	return typeof actual === "string" && actual.includes(String(expected));
+}
+function evaluateClause(clause, answers, onProblem) {
+	const actual = answers[clause.q];
+	const expected = clause.value;
+	switch (clause.op) {
+		case "eq": return looseEquals(actual, expected);
+		case "ne": return !looseEquals(actual, expected);
+		case "in": return anyOverlap(actual, expected);
+		case "not_in": return !anyOverlap(actual, expected);
+		case "gt": return asNumber(actual) > asNumber(expected);
+		case "lt": return asNumber(actual) < asNumber(expected);
+		case "gte": return asNumber(actual) >= asNumber(expected);
+		case "lte": return asNumber(actual) <= asNumber(expected);
+		case "contains": return contains(actual, expected);
+		case "not_contains": return !contains(actual, expected);
+		case "empty": return isBlank(actual);
+		case "not_empty": return !isBlank(actual);
+		default:
+			onProblem?.(`unknown operator "${String(clause.op)}" on "${String(clause.q)}": the target is shown`);
+			return true;
+	}
+}
+function evaluateCondition(condition, answers, onProblem) {
+	if (!condition) return true;
+	const clauses = Array.isArray(condition.all) ? condition.all : [];
+	if (clauses.length === 0) return true;
+	let result;
+	try {
+		result = clauses.every((c) => evaluateClause(c, answers, onProblem));
+	} catch (error) {
+		onProblem?.(`evaluation failed, the target is shown: ${error instanceof Error ? error.message : String(error)}`);
+		return true;
+	}
+	return condition.not === true ? !result : result;
+}
+var LEGACY_OPS = {
+	eq: "eq",
+	equals: "eq",
+	equal: "eq",
+	ne: "ne",
+	neq: "ne",
+	notequals: "ne",
+	notequal: "ne",
+	in: "in",
+	notin: "not_in",
+	gt: "gt",
+	greaterthan: "gt",
+	lt: "lt",
+	lessthan: "lt",
+	gte: "gte",
+	greaterthanorequal: "gte",
+	greaterthanorequals: "gte",
+	greaterthanorequalto: "gte",
+	lte: "lte",
+	lessthanorequal: "lte",
+	lessthanorequals: "lte",
+	lessthanorequalto: "lte",
+	contains: "contains",
+	notcontains: "not_contains",
+	empty: "empty",
+	isempty: "empty",
+	notempty: "not_empty",
+	isnotempty: "not_empty"
+};
+function normalizeOperator(op) {
+	if (typeof op !== "string") return null;
+	return LEGACY_OPS[op.replace(/[_\-\s]/g, "").toLowerCase()] ?? null;
+}
+function toClause(raw, index, problems) {
+	if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+		problems.push(`clause ${index}: not an object, dropped`);
+		return null;
+	}
+	const r = raw;
+	const q = [
+		r.q,
+		r.questionId,
+		r.when
+	].find((k) => typeof k === "string" && k !== "");
+	if (!q) {
+		problems.push(`clause ${index}: no question key, dropped`);
+		return null;
+	}
+	const value = "value" in r ? r.value : r.is;
+	const rawOp = r.op ?? r.operator;
+	if (rawOp === void 0 || rawOp === null || rawOp === "") return {
+		q,
+		op: "eq",
+		value
+	};
+	const op = normalizeOperator(rawOp);
+	if (op) return {
+		q,
+		op,
+		value
+	};
+	problems.push(`clause ${index} on "${q}": unknown operator "${String(rawOp)}", the target is shown`);
+	return {
+		q,
+		op: String(rawOp),
+		value
+	};
+}
+function normalizeCondition(legacy) {
+	const problems = [];
+	const none = () => ({
+		condition: null,
+		problems
+	});
+	if (legacy === null || legacy === void 0) return none();
+	let parsed = legacy;
+	if (typeof legacy === "string") {
+		const trimmed = legacy.trim();
+		if (trimmed === "") return none();
+		try {
+			parsed = JSON.parse(trimmed);
+		} catch {
+			problems.push("not JSON: ungated");
+			return none();
+		}
+	}
+	let rawClauses;
+	let not = false;
+	if (Array.isArray(parsed)) rawClauses = parsed;
+	else if (parsed && typeof parsed === "object") {
+		const obj = parsed;
+		const list = Array.isArray(obj.all) ? obj.all : Array.isArray(obj.conditions) ? obj.conditions : null;
+		if (!list) {
+			problems.push("no clause list (`all` or `conditions`): ungated");
+			return none();
+		}
+		rawClauses = list;
+		not = obj.not === true;
+	} else {
+		problems.push(`unrecognised condition (${typeof parsed}): ungated`);
+		return none();
+	}
+	const all = rawClauses.map((c, i) => toClause(c, i, problems)).filter((c) => c !== null);
+	if (all.length === 0) return none();
+	return {
+		condition: {
+			all,
+			not
+		},
+		problems
+	};
+}
+var answered = (v) => v !== void 0 && v !== null && !(typeof v === "string" && v.trim() === "") && !(Array.isArray(v) && v.length === 0);
+function visibleSteps(model, values) {
+	const shows = (when) => evaluateCondition(when ?? null, values);
+	return model.steps.filter((s) => shows(s.when)).map((s) => ({
+		...s,
+		items: s.items.filter((i) => shows(i.when)).map((i) => ({
+			...i,
+			questions: i.questions.filter((q) => shows(q.when))
+		}))
+	})).filter((s) => s.items.length > 0);
+}
+var questionsOf = (step) => step.items.flatMap((i) => i.questions);
+function stepKind(step, isLast) {
+	if (isLast && step.items.some((i) => i.kind === "review")) return "submit";
+	if (step.items.some((i) => i.kind === "upload")) return "upload";
+	if (questionsOf(step).length) return "answer";
+	if (step.items.some((i) => i.kind === "review")) return "review";
+	return "read";
+}
+function positionsOf(steps, mode) {
+	return steps.flatMap((s) => {
+		const qs = questionsOf(s);
+		return mode === "question" && qs.length ? qs.map((q) => ({
+			step: s.id,
+			question: q.key
+		})) : [{ step: s.id }];
+	});
+}
+var samePlace = (a, b) => a.step === b.step && (a.question ?? null) === (b.question ?? null);
+function settle(steps, mode, at) {
+	const all = positionsOf(steps, mode);
+	if (!all.length) return null;
+	if (at) {
+		const exact = all.find((p) => samePlace(p, mode === "step" ? { step: at.step } : at));
+		if (exact) return exact;
+		const inStep = all.find((p) => p.step === at.step);
+		if (inStep) return inStep;
+	}
+	return all[0];
+}
+function move(steps, mode, at, by) {
+	const all = positionsOf(steps, mode);
+	return all[all.findIndex((p) => samePlace(p, at)) + by] ?? null;
+}
+function goTo(steps, mode, stepId, values) {
+	const step = steps.find((s) => s.id === stepId);
+	if (!step) return null;
+	if (mode === "step") return { step: step.id };
+	const qs = questionsOf(step);
+	if (!qs.length) return { step: step.id };
+	return {
+		step: step.id,
+		question: (qs.find((q) => !answered(values[q.key])) ?? qs[0]).key
+	};
+}
+function goToQuestion(steps, mode, key) {
+	const step = steps.find((s) => questionsOf(s).some((q) => q.key === key));
+	if (!step) return null;
+	return mode === "question" ? {
+		step: step.id,
+		question: key
+	} : { step: step.id };
+}
+function enterAdvances(step, mode, question) {
+	const qs = questionsOf(step);
+	if (mode === "question") return !!question && !!qs.find((q) => q.key === question)?.singleLine;
+	return qs.length === 1 && qs[0].singleLine;
+}
+function missing(steps, values, stepId) {
+	return steps.filter((s) => !stepId || s.id === stepId).flatMap(questionsOf).filter((q) => q.required && !answered(values[q.key]));
+}
+function progress(steps, values, visited) {
+	const required = steps.flatMap(questionsOf).filter((q) => q.required);
+	const done = required.filter((q) => answered(values[q.key])).length;
+	const perStep = {};
+	steps.forEach((s, i) => {
+		const qs = questionsOf(s);
+		if (!qs.length) {
+			const seen = visited.has(s.id) ? 1 : 0;
+			perStep[s.id] = {
+				answered: seen,
+				total: 1,
+				complete: seen === 1 || stepKind(s, i === steps.length - 1) === "submit"
+			};
+			return;
+		}
+		const n = qs.filter((q) => answered(values[q.key])).length;
+		const required = qs.some((q) => q.required);
+		perStep[s.id] = {
+			answered: n,
+			total: qs.length,
+			complete: qs.every((q) => !q.required || answered(values[q.key])) && (required || n > 0 || visited.has(s.id))
+		};
+	});
+	const all = steps.flatMap(questionsOf);
+	const total = {
+		answered: all.filter((q) => answered(values[q.key])).length,
+		count: all.length
+	};
+	return {
+		answered: done,
+		required: required.length,
+		ratio: required.length ? done / required.length : 1,
+		total,
+		perStep
+	};
+}
+var isReadOnlyStatus = (status) => status === "submitted" || status === "completed";
+var defaultMode = (phone) => phone ? "question" : "step";
+function fromPageSteps(page, itemOf) {
+	const layout = page.layout ?? {};
+	const steps = Array.isArray(layout.steps) ? layout.steps : [];
+	const chapters = Array.isArray(layout.chapters) ? layout.chapters : [];
+	const submit = layout.submit ?? {};
+	return {
+		title: page.name ?? "",
+		chapters,
+		steps: steps.map((s) => ({
+			id: s.id,
+			title: s.title ?? s.id,
+			...s.chapter ? { chapter: s.chapter } : {},
+			...typeof s.label === "string" && s.label ? { label: s.label } : {},
+			...s.when ? { when: s.when } : {},
+			items: (s.cell_ids ?? []).map(itemOf).filter((i) => i !== null)
+		})),
+		submitRequired: submit.required === "block" ? "block" : "warn",
+		allowBack: layout.allow_back !== false
+	};
+}
+function positionFromLink(steps, mode, link) {
+	const step = link.section && steps.find((s) => s.id === link.section) || link.page && steps.find((s) => s.chapter === link.page) || steps[0];
+	if (!step) return null;
+	return settle(steps, mode, {
+		step: step.id,
+		...link.question && link.section === step.id ? { question: link.question } : {}
+	});
+}
+function linkTo(steps, mode, at) {
+	const step = steps.find((s) => s.id === at.step);
+	return {
+		...mode === "question" ? { mode: "question" } : {},
+		...step?.chapter ? { page: step.chapter } : {},
+		section: at.step,
+		...at.question ? { question: at.question } : {}
+	};
+}
+export { CONDITION_OPS as _, goToQuestion as a, normalizeCondition as b, missing as c, positionsOf as d, progress as f, visibleSteps as g, stepKind as h, goTo as i, move as l, settle as m, enterAdvances as n, isReadOnlyStatus as o, questionsOf as p, fromPageSteps as r, linkTo as s, defaultMode as t, positionFromLink as u, evaluateCondition as v, normalizeOperator as x, isConditionOp as y };

package/dist/chunks/{load-CjPvISzH.js → load-b38vUiZM.js}

@@ -1,5 +1,4 @@
 import { READY_GLOBAL } from "@peripheries/runtime";
-//#region packages/renderer/src/core/bundles/load.ts
 function isComponentExport(value) {
 	if (typeof value === "function") return true;
 	if (!value || typeof value !== "object") return false;
@@ -66,7 +65,4 @@ async function loadBundles(rows, files) {
 function _clearBundleCache() {
 	cache.clear();
 }
-//#endregion
 export { loadBundlesSettled as a, loadBundles as i, isComponentExport as n, projectModule as o, loadBundle as r, runtimeReady as s, _clearBundleCache as t };
-
-//# sourceMappingURL=load-CjPvISzH.js.map

package/dist/chunks/{page-bundles-DLRIBP8g.js → page-bundles-CPj_vx-J.js}

@@ -1,5 +1,4 @@
-import { a as normalizeRef, o as refKey } from "./refs-BLUokra5.js";
-//#region packages/renderer/src/core/bundles/page-bundles.ts
+import { a as normalizeRef, o as refKey } from "./refs-Csgh6rXq.js";
 function pageBundleRefs(scope, cells, pageOrgId) {
 	const out = [...scope];
 	const seen = new Set(out.map(refKey));
@@ -28,7 +27,4 @@ function pageBundles(scope, rows, loaded, pageOrgId, failed = false) {
 		}
 	};
 }
-//#endregion
 export { pageBundles as n, pageBundleRefs as t };
-
-//# sourceMappingURL=page-bundles-DLRIBP8g.js.map

package/dist/chunks/{persistence-DCMakM9H.js → persistence-hurkUUQ0.js}

@@ -1,5 +1,4 @@
 import { Store } from "@tanstack/store";
-//#region packages/renderer/src/core/store/create-store.ts
 function createStackStore(initial) {
 	const store = new Store({
 		selections: {},
@@ -89,8 +88,6 @@ function createStackStore(initial) {
 		subscribe: (listener) => store.subscribe(() => listener(getState()))
 	};
 }
-//#endregion
-//#region packages/renderer/src/core/store/persistence.ts
 var KEY_PREFIX = "stack.store.";
 function storageFor(mode) {
 	if (typeof window === "undefined" || mode === "none") return null;
@@ -134,7 +131,4 @@ function clearAllScopes() {
 		} catch {}
 	}
 }
-//#endregion
 export { createStackStore as a, saveScope as i, clearScope as n, loadScope as r, clearAllScopes as t };
-
-//# sourceMappingURL=persistence-DCMakM9H.js.map