fix(spec): view/layout-without-binding covers timeline, map and tree; new view/tree-without-parent-field

.changeset/view-binding-blocks-complete.md

@@ -0,0 +1,37 @@
+---
+'@objectstack/spec': minor
+'@objectstack/lint': patch
+---
+
+`view/layout-without-binding` now covers every view type that carries a binding block, and a new `view/tree-without-parent-field` rule catches the silently flat tree
+
+`checkViewCompleteness`'s `VIEW_BINDING_BLOCKS` table named `kanban` / `calendar` / `gantt` only, while
+`ListViewSchema.type` has six members with a type-specific binding block. The other three fell through
+the same trapdoor the rule exists to close: objectui's ListView adapter falls back to literal field
+names (`timeline` → `startDateField || 'created_at'`, `titleField || 'name'`; `map` →
+`locationField || 'location'`; `tree` → `labelField || titleField || 'name'`), so a view authored
+without its block rendered empty — `timeline` drops every row whose start date fails to parse —
+while `os validate --json` reported `warnings: []` and `valid: true`. Measured both ways: deleting a
+`timeline` block was silent, deleting the sibling `gantt` block warned as designed.
+
+- The table now names all six. Each new entry carries a `fix` hint naming the keys that make the block
+ a binding (`timeline`'s two schema-required keys; either coordinate form for `map`; `parentField` +
+ `labelField` for `tree`). Severity stays `warning` (ADR-0078 §1 — the view degrades, it does not die).
+- `map` is read for its coordinate binding, not merely for block presence: `ListMapConfigSchema` requires
+ no key, so a `map` block declaring neither `locationField` nor the `latitudeField`/`longitudeField`
+ pair is the same unbound view with braces and is warned about at `map.locationField`.
+- **New rule `view/tree-without-parent-field`** (warning, path `tree.parentField`): a `type: 'tree'` view
+ with no declared `parentField` on an object that carries neither a `tree` field nor a
+ `lookup`/`master_detail` back to itself renders FLAT — every record at depth 0, a correct-looking table
+ whose expand slot never opens. Every `TreeConfigSchema` key is optional, so `tree: {}` satisfies the
+ block check and still renders flat; this rule mirrors objectui's `detectParentField` exactly, so a
+ view the renderer resolves by auto-detection is never warned about.
+- `checkViewCompleteness(view, boundObject?)` takes the bound object definition as an optional second
+ argument (additive; one-argument callers are unchanged and the tree rule stays silent for them).
+ `@objectstack/lint`'s `validate-functional-completeness` resolves the object by name from
+ `stack.objects` — the list view's own `data.object` first, then the container's binding — and hands
+ it over; no rule logic moved into lint.
+- `gallery` is measured (`titleField || 'name'`) and deliberately not added: its schema has no binding key
+ to demand. `page` stays deliberately absent (a `page` view refuses at parse via `checkListViewPageMount`).
+
+Under `os validate --strict` the new warnings are failures, as every warning in this family is.

packages/lint/src/validate-functional-completeness.test.ts

@@ -15,6 +15,7 @@
 
 import { describe, expect, it } from 'vitest';
 
+import { runAuthoringRules, splitBySeverity } from './authoring-rules.js';
 import { validateFunctionalCompleteness } from './validate-functional-completeness.js';
 
 const bareSummary = { type: 'summary' };
@@ -85,6 +86,52 @@ describe('validateFunctionalCompleteness — the walk', () => {
  expect(findings.every((f) => f.severity === 'warning')).toBe(true);
  });
 
+ it('hands the bound object to the view predicate — the tree parent pointer resolves against `stack.objects`', () => {
+ // The predicate's tree rule needs the object's fields; this proves the
+ // walk actually delivers them, in every resolution the sibling
+ // reference-integrity rules use. Array-form objects, container binding:
+ const flat = validateFunctionalCompleteness({
+ objects: [{ name: 'unit', fields: [{ name: 'name', type: 'text' }] }],
+ views: [{ object: 'unit', listViews: { org: { type: 'tree', tree: {} } } }],
+ });
+ expect(flat.map((f) => [f.rule, f.severity, f.path])).toEqual([
+ ['view/tree-without-parent-field', 'warning', 'views[0].listViews.org.tree.parentField'],
+ ]);
+ expect(flat[0].where).toMatch(/› listViews\.org$/);
+
+ // Map-form objects (the walk injects `name`), a self-lookup → silent.
+ expect(validateFunctionalCompleteness({
+ objects: { unit: { fields: { parent: { type: 'lookup', reference: 'unit' } } } },
+ views: [{ object: 'unit', listViews: { org: { type: 'tree', tree: {} } } }],
+ })).toEqual([]);
+
+ // The container's default `list` slot is handed the object too.
+ expect(validateFunctionalCompleteness({
+ objects: [{ name: 'unit', fields: [] }],
+ views: [{ object: 'unit', list: { type: 'tree', tree: {} } }],
+ }).map((f) => f.path)).toEqual(['views[0].list.tree.parentField']);
+
+ // A list view's own `data.object` retargets the lookup (ADR-0047):
+ // `cat` carries a `tree` field, so the view bound to it is clean even
+ // though the container's object has nothing to detect.
+ expect(validateFunctionalCompleteness({
+ objects: [
+ { name: 'unit', fields: [] },
+ { name: 'cat', fields: [{ name: 'parent', type: 'tree' }] },
+ ],
+ views: [{
+ object: 'unit',
+ listViews: { org: { type: 'tree', tree: {}, data: { provider: 'object', object: 'cat' } } },
+ }],
+ })).toEqual([]);
+
+ // An object the stack does not declare: nothing is handed over and the
+ // tree rule stays silent — `validate-object-references` owns that miss.
+ expect(validateFunctionalCompleteness({
+ views: [{ object: 'ghost', listViews: { org: { type: 'tree', tree: {} } } }],
+ })).toEqual([]);
+ });
+
  it('walks webhooks in both spellings', () => {
  expect(validateFunctionalCompleteness({
  webhooks: [{ name: 'notify', url: 'https://x' }],
@@ -128,3 +175,72 @@ describe('validateFunctionalCompleteness — the walk', () => {
  }
  });
 });
+
+/**
+ * The card's acceptance criteria, pinned end-to-end through the rule table
+ * (the #14108 precedent): `timeline` / `map` / `tree` without their binding
+ * block must produce a diagnostic on `os validate` (and `os build`), and a
+ * `tree` view bound to an object with no self-reference must produce one
+ * whether its block is empty or absent. The clean twins prove the fixtures
+ * fail for the right reason.
+ */
+describe('#14106 acceptance — timeline / map / tree bindings reach `validate` AND `build`', () => {
+ const object = {
+ name: 'duly_task',
+ fields: {
+ subject: { type: 'text' },
+ last_update_at: { type: 'datetime' },
+ site: { type: 'text' },
+ },
+ };
+ const repro = {
+ objects: [object],
+ views: [{
+ object: 'duly_task',
+ listViews: {
+ recent: { type: 'timeline', columns: ['subject'] },
+ sites: { type: 'map', columns: ['subject'] },
+ flat: { type: 'tree', tree: {}, columns: ['subject'] },
+ flatter: { type: 'tree', columns: ['subject'] },
+ },
+ }],
+ };
+ const clean = {
+ objects: [{
+ ...object,
+ fields: { ...object.fields, parent: { type: 'lookup', reference: 'duly_task' } },
+ }],
+ views: [{
+ object: 'duly_task',
+ listViews: {
+ recent: {
+ type: 'timeline', columns: ['subject'],
+ timeline: { startDateField: 'last_update_at', titleField: 'subject' },
+ },
+ sites: { type: 'map', columns: ['subject'], map: { locationField: 'site' } },
+ flat: { type: 'tree', tree: {}, columns: ['subject'] },
+ declared: { type: 'tree', tree: { parentField: 'parent' }, columns: ['subject'] },
+ },
+ }],
+ };
+ const BINDING_RULES = ['view/layout-without-binding', 'view/tree-without-parent-field'];
+
+ for (const command of ['validate', 'build'] as const) {
+ it(`the measured repro is diagnosed by \`${command}\``, () => {
+ const { advisories } = splitBySeverity(runAuthoringRules(command, { normalized: repro as never }));
+ const hits = advisories.filter((f) => BINDING_RULES.includes(f.rule)).map((f) => `${f.rule} @ ${f.path}`).sort();
+ expect(hits).toEqual([
+ 'view/layout-without-binding @ views[0].listViews.flatter.tree',
+ 'view/layout-without-binding @ views[0].listViews.recent.timeline',
+ 'view/layout-without-binding @ views[0].listViews.sites.map',
+ 'view/tree-without-parent-field @ views[0].listViews.flat.tree.parentField',
+ 'view/tree-without-parent-field @ views[0].listViews.flatter.tree.parentField',
+ ]);
+ });
+
+ it(`the bound stack passes \`${command}\``, () => {
+ const { errors, advisories } = splitBySeverity(runAuthoringRules(command, { normalized: clean as never }));
+ expect([...errors, ...advisories].filter((f) => BINDING_RULES.includes(f.rule))).toEqual([]);
+ });
+ }
+});

packages/lint/src/validate-functional-completeness.ts

@@ -103,15 +103,38 @@ export function validateFunctionalCompleteness(stack: unknown): FunctionalComple
  // ── List views: views[] containers → list / listViews.* ────────────────
  // (Form views carry no layout-binding contract; field completeness inside
  // objects is already covered above.)
+ //
+ // The predicate takes the BOUND OBJECT as its optional second argument —
+ // the `tree` parent-pointer rule needs the object's fields to ask whether
+ // the renderer could auto-detect one. This is wiring only: the object is
+ // looked up by name in `stack.objects` (already normalized to an array, so
+ // both authorable spellings arrive with a `name`), resolved in the order
+ // the sibling reference-integrity rules use — a list view's own
+ // `data.object` retarget first (ADR-0047), then the container's binding —
+ // and handed over. Absent from the stack, nothing is handed and the
+ // predicate stays silent on that rule; the dangling `data.object` itself
+ // is `validate-object-references`' finding.
+ const objectsByName = new Map(entriesOf(stack.objects).map((o) => [o.name, o.def]));
+ const strName = (v: unknown): string | undefined => (typeof v === 'string' && v ? v : undefined);
+ const boundObjectOf = (view: AnyRec, container: AnyRec): AnyRec | undefined => {
+ const own = isRec(view.data) ? strName(view.data.object) : undefined;
+ const name = own ?? strName(container.objectName) ?? strName(container.object);
+ return name ? objectsByName.get(name) : undefined;
+ };
  for (const [vi, container] of entriesOf(stack.views).entries()) {
  const where = container.def.object ? `view container "${container.name}"` : `view container [${vi}]`;
  if (isRec(container.def.list)) {
- push(out, checkViewCompleteness(container.def.list), `${where} › list`, `views[${vi}].list`);
+ push(
+ out,
+ checkViewCompleteness(container.def.list, boundObjectOf(container.def.list, container.def)),
+ `${where} › list`,
+ `views[${vi}].list`,
+ );
  }
  for (const lv of entriesOf(container.def.listViews)) {
  push(
  out,
- checkViewCompleteness(lv.def),
+ checkViewCompleteness(lv.def, boundObjectOf(lv.def, container.def)),
  `${where} › listViews.${lv.name}`,
  `views[${vi}].listViews${lv.key}`,
  );

packages/spec/api-surface/kernel.json

@@ -442,6 +442,7 @@
  "UpgradeSnapshotParsed (type)",
  "UpgradeSnapshotSchema (const)",
  "VIEW_LAYOUT_WITHOUT_BINDING (const)",
+ "VIEW_TREE_WITHOUT_PARENT_FIELD (const)",
  "ValidationError (type)",
  "ValidationErrorSchema (const)",
  "ValidationResult (type)",

packages/spec/export-origins/kernel.json

@@ -442,6 +442,7 @@
  "UpgradeSnapshotParsed": "src/kernel/package-upgrade.zod.ts#UpgradeSnapshotParsed (type)",
  "UpgradeSnapshotSchema": "src/kernel/package-upgrade.zod.ts#UpgradeSnapshotSchema (const)",
  "VIEW_LAYOUT_WITHOUT_BINDING": "src/kernel/functional-completeness.ts#VIEW_LAYOUT_WITHOUT_BINDING (const)",
+ "VIEW_TREE_WITHOUT_PARENT_FIELD": "src/kernel/functional-completeness.ts#VIEW_TREE_WITHOUT_PARENT_FIELD (const)",
  "ValidationError": "src/kernel/plugin-validator.zod.ts#ValidationError (type)",
  "ValidationErrorSchema": "src/kernel/plugin-validator.zod.ts#ValidationErrorSchema (const)",
  "ValidationResult": "src/kernel/plugin-validator.zod.ts#ValidationResult (type)",

.changeset/view-binding-blocks-complete.md

@@ -0,0 +1,37 @@
+---
+'@objectstack/spec': minor
+'@objectstack/lint': patch
+---
+
+`view/layout-without-binding` now covers every view type that carries a binding block, and a new `view/tree-without-parent-field` rule catches the silently flat tree
+
+`checkViewCompleteness`'s `VIEW_BINDING_BLOCKS` table named `kanban` / `calendar` / `gantt` only, while
+`ListViewSchema.type` has six members with a type-specific binding block. The other three fell through
+the same trapdoor the rule exists to close: objectui's ListView adapter falls back to literal field
+names (`timeline` → `startDateField || 'created_at'`, `titleField || 'name'`; `map` →
+`locationField || 'location'`; `tree` → `labelField || titleField || 'name'`), so a view authored
+without its block rendered empty — `timeline` drops every row whose start date fails to parse —
+while `os validate --json` reported `warnings: []` and `valid: true`. Measured both ways: deleting a
+`timeline` block was silent, deleting the sibling `gantt` block warned as designed.
+
+- The table now names all six. Each new entry carries a `fix` hint naming the keys that make the block
+ a binding (`timeline`'s two schema-required keys; either coordinate form for `map`; `parentField` +
+ `labelField` for `tree`). Severity stays `warning` (ADR-0078 §1 — the view degrades, it does not die).
+- `map` is read for its coordinate binding, not merely for block presence: `ListMapConfigSchema` requires
+ no key, so a `map` block declaring neither `locationField` nor the `latitudeField`/`longitudeField`
+ pair is the same unbound view with braces and is warned about at `map.locationField`.
+- **New rule `view/tree-without-parent-field`** (warning, path `tree.parentField`): a `type: 'tree'` view
+ with no declared `parentField` on an object that carries neither a `tree` field nor a
+ `lookup`/`master_detail` back to itself renders FLAT — every record at depth 0, a correct-looking table
+ whose expand slot never opens. Every `TreeConfigSchema` key is optional, so `tree: {}` satisfies the
+ block check and still renders flat; this rule mirrors objectui's `detectParentField` exactly, so a
+ view the renderer resolves by auto-detection is never warned about.
+- `checkViewCompleteness(view, boundObject?)` takes the bound object definition as an optional second
+ argument (additive; one-argument callers are unchanged and the tree rule stays silent for them).
+ `@objectstack/lint`'s `validate-functional-completeness` resolves the object by name from
+ `stack.objects` — the list view's own `data.object` first, then the container's binding — and hands
+ it over; no rule logic moved into lint.
+- `gallery` is measured (`titleField || 'name'`) and deliberately not added: its schema has no binding key
+ to demand. `page` stays deliberately absent (a `page` view refuses at parse via `checkListViewPageMount`).
+
+Under `os validate --strict` the new warnings are failures, as every warning in this family is.

packages/lint/src/validate-functional-completeness.test.ts

@@ -15,6 +15,7 @@
 
 import { describe, expect, it } from 'vitest';
 
+import { runAuthoringRules, splitBySeverity } from './authoring-rules.js';
 import { validateFunctionalCompleteness } from './validate-functional-completeness.js';
 
 const bareSummary = { type: 'summary' };
@@ -85,6 +86,52 @@ describe('validateFunctionalCompleteness — the walk', () => {
  expect(findings.every((f) => f.severity === 'warning')).toBe(true);
  });
 
+ it('hands the bound object to the view predicate — the tree parent pointer resolves against `stack.objects`', () => {
+ // The predicate's tree rule needs the object's fields; this proves the
+ // walk actually delivers them, in every resolution the sibling
+ // reference-integrity rules use. Array-form objects, container binding:
+ const flat = validateFunctionalCompleteness({
+ objects: [{ name: 'unit', fields: [{ name: 'name', type: 'text' }] }],
+ views: [{ object: 'unit', listViews: { org: { type: 'tree', tree: {} } } }],
+ });
+ expect(flat.map((f) => [f.rule, f.severity, f.path])).toEqual([
+ ['view/tree-without-parent-field', 'warning', 'views[0].listViews.org.tree.parentField'],
+ ]);
+ expect(flat[0].where).toMatch(/› listViews\.org$/);
+
+ // Map-form objects (the walk injects `name`), a self-lookup → silent.
+ expect(validateFunctionalCompleteness({
+ objects: { unit: { fields: { parent: { type: 'lookup', reference: 'unit' } } } },
+ views: [{ object: 'unit', listViews: { org: { type: 'tree', tree: {} } } }],
+ })).toEqual([]);
+
+ // The container's default `list` slot is handed the object too.
+ expect(validateFunctionalCompleteness({
+ objects: [{ name: 'unit', fields: [] }],
+ views: [{ object: 'unit', list: { type: 'tree', tree: {} } }],
+ }).map((f) => f.path)).toEqual(['views[0].list.tree.parentField']);
+
+ // A list view's own `data.object` retargets the lookup (ADR-0047):
+ // `cat` carries a `tree` field, so the view bound to it is clean even
+ // though the container's object has nothing to detect.
+ expect(validateFunctionalCompleteness({
+ objects: [
+ { name: 'unit', fields: [] },
+ { name: 'cat', fields: [{ name: 'parent', type: 'tree' }] },
+ ],
+ views: [{
+ object: 'unit',
+ listViews: { org: { type: 'tree', tree: {}, data: { provider: 'object', object: 'cat' } } },
+ }],
+ })).toEqual([]);
+
+ // An object the stack does not declare: nothing is handed over and the
+ // tree rule stays silent — `validate-object-references` owns that miss.
+ expect(validateFunctionalCompleteness({
+ views: [{ object: 'ghost', listViews: { org: { type: 'tree', tree: {} } } }],
+ })).toEqual([]);
+ });
+
  it('walks webhooks in both spellings', () => {
  expect(validateFunctionalCompleteness({
  webhooks: [{ name: 'notify', url: 'https://x' }],
@@ -128,3 +175,72 @@ describe('validateFunctionalCompleteness — the walk', () => {
  }
  });
 });
+
+/**
+ * The card's acceptance criteria, pinned end-to-end through the rule table
+ * (the #14108 precedent): `timeline` / `map` / `tree` without their binding
+ * block must produce a diagnostic on `os validate` (and `os build`), and a
+ * `tree` view bound to an object with no self-reference must produce one
+ * whether its block is empty or absent. The clean twins prove the fixtures
+ * fail for the right reason.
+ */
+describe('#14106 acceptance — timeline / map / tree bindings reach `validate` AND `build`', () => {
+ const object = {
+ name: 'duly_task',
+ fields: {
+ subject: { type: 'text' },
+ last_update_at: { type: 'datetime' },
+ site: { type: 'text' },
+ },
+ };
+ const repro = {
+ objects: [object],
+ views: [{
+ object: 'duly_task',
+ listViews: {
+ recent: { type: 'timeline', columns: ['subject'] },
+ sites: { type: 'map', columns: ['subject'] },
+ flat: { type: 'tree', tree: {}, columns: ['subject'] },
+ flatter: { type: 'tree', columns: ['subject'] },
+ },
+ }],
+ };
+ const clean = {
+ objects: [{
+ ...object,
+ fields: { ...object.fields, parent: { type: 'lookup', reference: 'duly_task' } },
+ }],
+ views: [{
+ object: 'duly_task',
+ listViews: {
+ recent: {
+ type: 'timeline', columns: ['subject'],
+ timeline: { startDateField: 'last_update_at', titleField: 'subject' },
+ },
+ sites: { type: 'map', columns: ['subject'], map: { locationField: 'site' } },
+ flat: { type: 'tree', tree: {}, columns: ['subject'] },
+ declared: { type: 'tree', tree: { parentField: 'parent' }, columns: ['subject'] },
+ },
+ }],
+ };
+ const BINDING_RULES = ['view/layout-without-binding', 'view/tree-without-parent-field'];
+
+ for (const command of ['validate', 'build'] as const) {
+ it(`the measured repro is diagnosed by \`${command}\``, () => {
+ const { advisories } = splitBySeverity(runAuthoringRules(command, { normalized: repro as never }));
+ const hits = advisories.filter((f) => BINDING_RULES.includes(f.rule)).map((f) => `${f.rule} @ ${f.path}`).sort();
+ expect(hits).toEqual([
+ 'view/layout-without-binding @ views[0].listViews.flatter.tree',
+ 'view/layout-without-binding @ views[0].listViews.recent.timeline',
+ 'view/layout-without-binding @ views[0].listViews.sites.map',
+ 'view/tree-without-parent-field @ views[0].listViews.flat.tree.parentField',
+ 'view/tree-without-parent-field @ views[0].listViews.flatter.tree.parentField',
+ ]);
+ });
+
+ it(`the bound stack passes \`${command}\``, () => {
+ const { errors, advisories } = splitBySeverity(runAuthoringRules(command, { normalized: clean as never }));
+ expect([...errors, ...advisories].filter((f) => BINDING_RULES.includes(f.rule))).toEqual([]);
+ });
+ }
+});

packages/lint/src/validate-functional-completeness.ts

@@ -103,15 +103,38 @@ export function validateFunctionalCompleteness(stack: unknown): FunctionalComple
  // ── List views: views[] containers → list / listViews.* ────────────────
  // (Form views carry no layout-binding contract; field completeness inside
  // objects is already covered above.)
+ //
+ // The predicate takes the BOUND OBJECT as its optional second argument —
+ // the `tree` parent-pointer rule needs the object's fields to ask whether
+ // the renderer could auto-detect one. This is wiring only: the object is
+ // looked up by name in `stack.objects` (already normalized to an array, so
+ // both authorable spellings arrive with a `name`), resolved in the order
+ // the sibling reference-integrity rules use — a list view's own
+ // `data.object` retarget first (ADR-0047), then the container's binding —
+ // and handed over. Absent from the stack, nothing is handed and the
+ // predicate stays silent on that rule; the dangling `data.object` itself
+ // is `validate-object-references`' finding.
+ const objectsByName = new Map(entriesOf(stack.objects).map((o) => [o.name, o.def]));
+ const strName = (v: unknown): string | undefined => (typeof v === 'string' && v ? v : undefined);
+ const boundObjectOf = (view: AnyRec, container: AnyRec): AnyRec | undefined => {
+ const own = isRec(view.data) ? strName(view.data.object) : undefined;
+ const name = own ?? strName(container.objectName) ?? strName(container.object);
+ return name ? objectsByName.get(name) : undefined;
+ };
  for (const [vi, container] of entriesOf(stack.views).entries()) {
  const where = container.def.object ? `view container "${container.name}"` : `view container [${vi}]`;
  if (isRec(container.def.list)) {
- push(out, checkViewCompleteness(container.def.list), `${where} › list`, `views[${vi}].list`);
+ push(
+ out,
+ checkViewCompleteness(container.def.list, boundObjectOf(container.def.list, container.def)),
+ `${where} › list`,
+ `views[${vi}].list`,
+ );
  }
  for (const lv of entriesOf(container.def.listViews)) {
  push(
  out,
- checkViewCompleteness(lv.def),
+ checkViewCompleteness(lv.def, boundObjectOf(lv.def, container.def)),
  `${where} › listViews.${lv.name}`,
  `views[${vi}].listViews${lv.key}`,
  );

packages/spec/api-surface/kernel.json

@@ -442,6 +442,7 @@
  "UpgradeSnapshotParsed (type)",
  "UpgradeSnapshotSchema (const)",
  "VIEW_LAYOUT_WITHOUT_BINDING (const)",
+ "VIEW_TREE_WITHOUT_PARENT_FIELD (const)",
  "ValidationError (type)",
  "ValidationErrorSchema (const)",
  "ValidationResult (type)",

packages/spec/export-origins/kernel.json

@@ -442,6 +442,7 @@
  "UpgradeSnapshotParsed": "src/kernel/package-upgrade.zod.ts#UpgradeSnapshotParsed (type)",
  "UpgradeSnapshotSchema": "src/kernel/package-upgrade.zod.ts#UpgradeSnapshotSchema (const)",
  "VIEW_LAYOUT_WITHOUT_BINDING": "src/kernel/functional-completeness.ts#VIEW_LAYOUT_WITHOUT_BINDING (const)",
+ "VIEW_TREE_WITHOUT_PARENT_FIELD": "src/kernel/functional-completeness.ts#VIEW_TREE_WITHOUT_PARENT_FIELD (const)",
  "ValidationError": "src/kernel/plugin-validator.zod.ts#ValidationError (type)",
  "ValidationErrorSchema": "src/kernel/plugin-validator.zod.ts#ValidationErrorSchema (const)",
  "ValidationResult": "src/kernel/plugin-validator.zod.ts#ValidationResult (type)",

.changeset/view-binding-blocks-complete.md

@@ -0,0 +1,37 @@
+---
+'@objectstack/spec': minor
+'@objectstack/lint': patch
+---
+
+`view/layout-without-binding` now covers every view type that carries a binding block, and a new `view/tree-without-parent-field` rule catches the silently flat tree
+
+`checkViewCompleteness`'s `VIEW_BINDING_BLOCKS` table named `kanban` / `calendar` / `gantt` only, while
+`ListViewSchema.type` has six members with a type-specific binding block. The other three fell through
+the same trapdoor the rule exists to close: objectui's ListView adapter falls back to literal field
+names (`timeline` → `startDateField || 'created_at'`, `titleField || 'name'`; `map` →
+`locationField || 'location'`; `tree` → `labelField || titleField || 'name'`), so a view authored
+without its block rendered empty — `timeline` drops every row whose start date fails to parse —
+while `os validate --json` reported `warnings: []` and `valid: true`. Measured both ways: deleting a
+`timeline` block was silent, deleting the sibling `gantt` block warned as designed.
+
+- The table now names all six. Each new entry carries a `fix` hint naming the keys that make the block
+ a binding (`timeline`'s two schema-required keys; either coordinate form for `map`; `parentField` +
+ `labelField` for `tree`). Severity stays `warning` (ADR-0078 §1 — the view degrades, it does not die).
+- `map` is read for its coordinate binding, not merely for block presence: `ListMapConfigSchema` requires
+ no key, so a `map` block declaring neither `locationField` nor the `latitudeField`/`longitudeField`
+ pair is the same unbound view with braces and is warned about at `map.locationField`.
+- **New rule `view/tree-without-parent-field`** (warning, path `tree.parentField`): a `type: 'tree'` view
+ with no declared `parentField` on an object that carries neither a `tree` field nor a
+ `lookup`/`master_detail` back to itself renders FLAT — every record at depth 0, a correct-looking table
+ whose expand slot never opens. Every `TreeConfigSchema` key is optional, so `tree: {}` satisfies the
+ block check and still renders flat; this rule mirrors objectui's `detectParentField` exactly, so a
+ view the renderer resolves by auto-detection is never warned about.
+- `checkViewCompleteness(view, boundObject?)` takes the bound object definition as an optional second
+ argument (additive; one-argument callers are unchanged and the tree rule stays silent for them).
+ `@objectstack/lint`'s `validate-functional-completeness` resolves the object by name from
+ `stack.objects` — the list view's own `data.object` first, then the container's binding — and hands
+ it over; no rule logic moved into lint.
+- `gallery` is measured (`titleField || 'name'`) and deliberately not added: its schema has no binding key
+ to demand. `page` stays deliberately absent (a `page` view refuses at parse via `checkListViewPageMount`).
+
+Under `os validate --strict` the new warnings are failures, as every warning in this family is.

packages/lint/src/validate-functional-completeness.test.ts

@@ -15,6 +15,7 @@
 
 import { describe, expect, it } from 'vitest';
 
+import { runAuthoringRules, splitBySeverity } from './authoring-rules.js';
 import { validateFunctionalCompleteness } from './validate-functional-completeness.js';
 
 const bareSummary = { type: 'summary' };
@@ -85,6 +86,52 @@ describe('validateFunctionalCompleteness — the walk', () => {
  expect(findings.every((f) => f.severity === 'warning')).toBe(true);
  });
 
+ it('hands the bound object to the view predicate — the tree parent pointer resolves against `stack.objects`', () => {
+ // The predicate's tree rule needs the object's fields; this proves the
+ // walk actually delivers them, in every resolution the sibling
+ // reference-integrity rules use. Array-form objects, container binding:
+ const flat = validateFunctionalCompleteness({
+ objects: [{ name: 'unit', fields: [{ name: 'name', type: 'text' }] }],
+ views: [{ object: 'unit', listViews: { org: { type: 'tree', tree: {} } } }],
+ });
+ expect(flat.map((f) => [f.rule, f.severity, f.path])).toEqual([
+ ['view/tree-without-parent-field', 'warning', 'views[0].listViews.org.tree.parentField'],
+ ]);
+ expect(flat[0].where).toMatch(/› listViews\.org$/);
+
+ // Map-form objects (the walk injects `name`), a self-lookup → silent.
+ expect(validateFunctionalCompleteness({
+ objects: { unit: { fields: { parent: { type: 'lookup', reference: 'unit' } } } },
+ views: [{ object: 'unit', listViews: { org: { type: 'tree', tree: {} } } }],
+ })).toEqual([]);
+
+ // The container's default `list` slot is handed the object too.
+ expect(validateFunctionalCompleteness({
+ objects: [{ name: 'unit', fields: [] }],
+ views: [{ object: 'unit', list: { type: 'tree', tree: {} } }],
+ }).map((f) => f.path)).toEqual(['views[0].list.tree.parentField']);
+
+ // A list view's own `data.object` retargets the lookup (ADR-0047):
+ // `cat` carries a `tree` field, so the view bound to it is clean even
+ // though the container's object has nothing to detect.
+ expect(validateFunctionalCompleteness({
+ objects: [
+ { name: 'unit', fields: [] },
+ { name: 'cat', fields: [{ name: 'parent', type: 'tree' }] },
+ ],
+ views: [{
+ object: 'unit',
+ listViews: { org: { type: 'tree', tree: {}, data: { provider: 'object', object: 'cat' } } },
+ }],
+ })).toEqual([]);
+
+ // An object the stack does not declare: nothing is handed over and the
+ // tree rule stays silent — `validate-object-references` owns that miss.
+ expect(validateFunctionalCompleteness({
+ views: [{ object: 'ghost', listViews: { org: { type: 'tree', tree: {} } } }],
+ })).toEqual([]);
+ });
+
  it('walks webhooks in both spellings', () => {
  expect(validateFunctionalCompleteness({
  webhooks: [{ name: 'notify', url: 'https://x' }],
@@ -128,3 +175,72 @@ describe('validateFunctionalCompleteness — the walk', () => {
  }
  });
 });
+
+/**
+ * The card's acceptance criteria, pinned end-to-end through the rule table
+ * (the #14108 precedent): `timeline` / `map` / `tree` without their binding
+ * block must produce a diagnostic on `os validate` (and `os build`), and a
+ * `tree` view bound to an object with no self-reference must produce one
+ * whether its block is empty or absent. The clean twins prove the fixtures
+ * fail for the right reason.
+ */
+describe('#14106 acceptance — timeline / map / tree bindings reach `validate` AND `build`', () => {
+ const object = {
+ name: 'duly_task',
+ fields: {
+ subject: { type: 'text' },
+ last_update_at: { type: 'datetime' },
+ site: { type: 'text' },
+ },
+ };
+ const repro = {
+ objects: [object],
+ views: [{
+ object: 'duly_task',
+ listViews: {
+ recent: { type: 'timeline', columns: ['subject'] },
+ sites: { type: 'map', columns: ['subject'] },
+ flat: { type: 'tree', tree: {}, columns: ['subject'] },
+ flatter: { type: 'tree', columns: ['subject'] },
+ },
+ }],
+ };
+ const clean = {
+ objects: [{
+ ...object,
+ fields: { ...object.fields, parent: { type: 'lookup', reference: 'duly_task' } },
+ }],
+ views: [{
+ object: 'duly_task',
+ listViews: {
+ recent: {
+ type: 'timeline', columns: ['subject'],
+ timeline: { startDateField: 'last_update_at', titleField: 'subject' },
+ },
+ sites: { type: 'map', columns: ['subject'], map: { locationField: 'site' } },
+ flat: { type: 'tree', tree: {}, columns: ['subject'] },
+ declared: { type: 'tree', tree: { parentField: 'parent' }, columns: ['subject'] },
+ },
+ }],
+ };
+ const BINDING_RULES = ['view/layout-without-binding', 'view/tree-without-parent-field'];
+
+ for (const command of ['validate', 'build'] as const) {
+ it(`the measured repro is diagnosed by \`${command}\``, () => {
+ const { advisories } = splitBySeverity(runAuthoringRules(command, { normalized: repro as never }));
+ const hits = advisories.filter((f) => BINDING_RULES.includes(f.rule)).map((f) => `${f.rule} @ ${f.path}`).sort();
+ expect(hits).toEqual([
+ 'view/layout-without-binding @ views[0].listViews.flatter.tree',
+ 'view/layout-without-binding @ views[0].listViews.recent.timeline',
+ 'view/layout-without-binding @ views[0].listViews.sites.map',
+ 'view/tree-without-parent-field @ views[0].listViews.flat.tree.parentField',
+ 'view/tree-without-parent-field @ views[0].listViews.flatter.tree.parentField',
+ ]);
+ });
+
+ it(`the bound stack passes \`${command}\``, () => {
+ const { errors, advisories } = splitBySeverity(runAuthoringRules(command, { normalized: clean as never }));
+ expect([...errors, ...advisories].filter((f) => BINDING_RULES.includes(f.rule))).toEqual([]);
+ });
+ }
+});

packages/lint/src/validate-functional-completeness.ts

@@ -103,15 +103,38 @@ export function validateFunctionalCompleteness(stack: unknown): FunctionalComple
  // ── List views: views[] containers → list / listViews.* ────────────────
  // (Form views carry no layout-binding contract; field completeness inside
  // objects is already covered above.)
+ //
+ // The predicate takes the BOUND OBJECT as its optional second argument —
+ // the `tree` parent-pointer rule needs the object's fields to ask whether
+ // the renderer could auto-detect one. This is wiring only: the object is
+ // looked up by name in `stack.objects` (already normalized to an array, so
+ // both authorable spellings arrive with a `name`), resolved in the order
+ // the sibling reference-integrity rules use — a list view's own
+ // `data.object` retarget first (ADR-0047), then the container's binding —
+ // and handed over. Absent from the stack, nothing is handed and the
+ // predicate stays silent on that rule; the dangling `data.object` itself
+ // is `validate-object-references`' finding.
+ const objectsByName = new Map(entriesOf(stack.objects).map((o) => [o.name, o.def]));
+ const strName = (v: unknown): string | undefined => (typeof v === 'string' && v ? v : undefined);
+ const boundObjectOf = (view: AnyRec, container: AnyRec): AnyRec | undefined => {
+ const own = isRec(view.data) ? strName(view.data.object) : undefined;
+ const name = own ?? strName(container.objectName) ?? strName(container.object);
+ return name ? objectsByName.get(name) : undefined;
+ };
  for (const [vi, container] of entriesOf(stack.views).entries()) {
  const where = container.def.object ? `view container "${container.name}"` : `view container [${vi}]`;
  if (isRec(container.def.list)) {
- push(out, checkViewCompleteness(container.def.list), `${where} › list`, `views[${vi}].list`);
+ push(
+ out,
+ checkViewCompleteness(container.def.list, boundObjectOf(container.def.list, container.def)),
+ `${where} › list`,
+ `views[${vi}].list`,
+ );
  }
  for (const lv of entriesOf(container.def.listViews)) {
  push(
  out,
- checkViewCompleteness(lv.def),
+ checkViewCompleteness(lv.def, boundObjectOf(lv.def, container.def)),
  `${where} › listViews.${lv.name}`,
  `views[${vi}].listViews${lv.key}`,
  );

packages/spec/api-surface/kernel.json

@@ -442,6 +442,7 @@
  "UpgradeSnapshotParsed (type)",
  "UpgradeSnapshotSchema (const)",
  "VIEW_LAYOUT_WITHOUT_BINDING (const)",
+ "VIEW_TREE_WITHOUT_PARENT_FIELD (const)",
  "ValidationError (type)",
  "ValidationErrorSchema (const)",
  "ValidationResult (type)",

packages/spec/export-origins/kernel.json

@@ -442,6 +442,7 @@
  "UpgradeSnapshotParsed": "src/kernel/package-upgrade.zod.ts#UpgradeSnapshotParsed (type)",
  "UpgradeSnapshotSchema": "src/kernel/package-upgrade.zod.ts#UpgradeSnapshotSchema (const)",
  "VIEW_LAYOUT_WITHOUT_BINDING": "src/kernel/functional-completeness.ts#VIEW_LAYOUT_WITHOUT_BINDING (const)",
+ "VIEW_TREE_WITHOUT_PARENT_FIELD": "src/kernel/functional-completeness.ts#VIEW_TREE_WITHOUT_PARENT_FIELD (const)",
  "ValidationError": "src/kernel/plugin-validator.zod.ts#ValidationError (type)",
  "ValidationErrorSchema": "src/kernel/plugin-validator.zod.ts#ValidationErrorSchema (const)",
  "ValidationResult": "src/kernel/plugin-validator.zod.ts#ValidationResult (type)",

.changeset/view-binding-blocks-complete.md

@@ -0,0 +1,37 @@
+---
+'@objectstack/spec': minor
+'@objectstack/lint': patch
+---
+
+`view/layout-without-binding` now covers every view type that carries a binding block, and a new `view/tree-without-parent-field` rule catches the silently flat tree
+
+`checkViewCompleteness`'s `VIEW_BINDING_BLOCKS` table named `kanban` / `calendar` / `gantt` only, while
+`ListViewSchema.type` has six members with a type-specific binding block. The other three fell through
+the same trapdoor the rule exists to close: objectui's ListView adapter falls back to literal field
+names (`timeline` → `startDateField || 'created_at'`, `titleField || 'name'`; `map` →
+`locationField || 'location'`; `tree` → `labelField || titleField || 'name'`), so a view authored
+without its block rendered empty — `timeline` drops every row whose start date fails to parse —
+while `os validate --json` reported `warnings: []` and `valid: true`. Measured both ways: deleting a
+`timeline` block was silent, deleting the sibling `gantt` block warned as designed.
+
+- The table now names all six. Each new entry carries a `fix` hint naming the keys that make the block
+ a binding (`timeline`'s two schema-required keys; either coordinate form for `map`; `parentField` +
+ `labelField` for `tree`). Severity stays `warning` (ADR-0078 §1 — the view degrades, it does not die).
+- `map` is read for its coordinate binding, not merely for block presence: `ListMapConfigSchema` requires
+ no key, so a `map` block declaring neither `locationField` nor the `latitudeField`/`longitudeField`
+ pair is the same unbound view with braces and is warned about at `map.locationField`.
+- **New rule `view/tree-without-parent-field`** (warning, path `tree.parentField`): a `type: 'tree'` view
+ with no declared `parentField` on an object that carries neither a `tree` field nor a
+ `lookup`/`master_detail` back to itself renders FLAT — every record at depth 0, a correct-looking table
+ whose expand slot never opens. Every `TreeConfigSchema` key is optional, so `tree: {}` satisfies the
+ block check and still renders flat; this rule mirrors objectui's `detectParentField` exactly, so a
+ view the renderer resolves by auto-detection is never warned about.
+- `checkViewCompleteness(view, boundObject?)` takes the bound object definition as an optional second
+ argument (additive; one-argument callers are unchanged and the tree rule stays silent for them).
+ `@objectstack/lint`'s `validate-functional-completeness` resolves the object by name from
+ `stack.objects` — the list view's own `data.object` first, then the container's binding — and hands
+ it over; no rule logic moved into lint.
+- `gallery` is measured (`titleField || 'name'`) and deliberately not added: its schema has no binding key
+ to demand. `page` stays deliberately absent (a `page` view refuses at parse via `checkListViewPageMount`).
+
+Under `os validate --strict` the new warnings are failures, as every warning in this family is.

packages/lint/src/validate-functional-completeness.test.ts

@@ -15,6 +15,7 @@
 
 import { describe, expect, it } from 'vitest';
 
+import { runAuthoringRules, splitBySeverity } from './authoring-rules.js';
 import { validateFunctionalCompleteness } from './validate-functional-completeness.js';
 
 const bareSummary = { type: 'summary' };
@@ -85,6 +86,52 @@ describe('validateFunctionalCompleteness — the walk', () => {
  expect(findings.every((f) => f.severity === 'warning')).toBe(true);
  });
 
+ it('hands the bound object to the view predicate — the tree parent pointer resolves against `stack.objects`', () => {
+ // The predicate's tree rule needs the object's fields; this proves the
+ // walk actually delivers them, in every resolution the sibling
+ // reference-integrity rules use. Array-form objects, container binding:
+ const flat = validateFunctionalCompleteness({
+ objects: [{ name: 'unit', fields: [{ name: 'name', type: 'text' }] }],
+ views: [{ object: 'unit', listViews: { org: { type: 'tree', tree: {} } } }],
+ });
+ expect(flat.map((f) => [f.rule, f.severity, f.path])).toEqual([
+ ['view/tree-without-parent-field', 'warning', 'views[0].listViews.org.tree.parentField'],
+ ]);
+ expect(flat[0].where).toMatch(/› listViews\.org$/);
+
+ // Map-form objects (the walk injects `name`), a self-lookup → silent.
+ expect(validateFunctionalCompleteness({
+ objects: { unit: { fields: { parent: { type: 'lookup', reference: 'unit' } } } },
+ views: [{ object: 'unit', listViews: { org: { type: 'tree', tree: {} } } }],
+ })).toEqual([]);
+
+ // The container's default `list` slot is handed the object too.
+ expect(validateFunctionalCompleteness({
+ objects: [{ name: 'unit', fields: [] }],
+ views: [{ object: 'unit', list: { type: 'tree', tree: {} } }],
+ }).map((f) => f.path)).toEqual(['views[0].list.tree.parentField']);
+
+ // A list view's own `data.object` retargets the lookup (ADR-0047):
+ // `cat` carries a `tree` field, so the view bound to it is clean even
+ // though the container's object has nothing to detect.
+ expect(validateFunctionalCompleteness({
+ objects: [
+ { name: 'unit', fields: [] },
+ { name: 'cat', fields: [{ name: 'parent', type: 'tree' }] },
+ ],
+ views: [{
+ object: 'unit',
+ listViews: { org: { type: 'tree', tree: {}, data: { provider: 'object', object: 'cat' } } },
+ }],
+ })).toEqual([]);
+
+ // An object the stack does not declare: nothing is handed over and the
+ // tree rule stays silent — `validate-object-references` owns that miss.
+ expect(validateFunctionalCompleteness({
+ views: [{ object: 'ghost', listViews: { org: { type: 'tree', tree: {} } } }],
+ })).toEqual([]);
+ });
+
  it('walks webhooks in both spellings', () => {
  expect(validateFunctionalCompleteness({
  webhooks: [{ name: 'notify', url: 'https://x' }],
@@ -128,3 +175,72 @@ describe('validateFunctionalCompleteness — the walk', () => {
  }
  });
 });
+
+/**
+ * The card's acceptance criteria, pinned end-to-end through the rule table
+ * (the #14108 precedent): `timeline` / `map` / `tree` without their binding
+ * block must produce a diagnostic on `os validate` (and `os build`), and a
+ * `tree` view bound to an object with no self-reference must produce one
+ * whether its block is empty or absent. The clean twins prove the fixtures
+ * fail for the right reason.
+ */
+describe('#14106 acceptance — timeline / map / tree bindings reach `validate` AND `build`', () => {
+ const object = {
+ name: 'duly_task',
+ fields: {
+ subject: { type: 'text' },
+ last_update_at: { type: 'datetime' },
+ site: { type: 'text' },
+ },
+ };
+ const repro = {
+ objects: [object],
+ views: [{
+ object: 'duly_task',
+ listViews: {
+ recent: { type: 'timeline', columns: ['subject'] },
+ sites: { type: 'map', columns: ['subject'] },
+ flat: { type: 'tree', tree: {}, columns: ['subject'] },
+ flatter: { type: 'tree', columns: ['subject'] },
+ },
+ }],
+ };
+ const clean = {
+ objects: [{
+ ...object,
+ fields: { ...object.fields, parent: { type: 'lookup', reference: 'duly_task' } },
+ }],
+ views: [{
+ object: 'duly_task',
+ listViews: {
+ recent: {
+ type: 'timeline', columns: ['subject'],
+ timeline: { startDateField: 'last_update_at', titleField: 'subject' },
+ },
+ sites: { type: 'map', columns: ['subject'], map: { locationField: 'site' } },
+ flat: { type: 'tree', tree: {}, columns: ['subject'] },
+ declared: { type: 'tree', tree: { parentField: 'parent' }, columns: ['subject'] },
+ },
+ }],
+ };
+ const BINDING_RULES = ['view/layout-without-binding', 'view/tree-without-parent-field'];
+
+ for (const command of ['validate', 'build'] as const) {
+ it(`the measured repro is diagnosed by \`${command}\``, () => {
+ const { advisories } = splitBySeverity(runAuthoringRules(command, { normalized: repro as never }));
+ const hits = advisories.filter((f) => BINDING_RULES.includes(f.rule)).map((f) => `${f.rule} @ ${f.path}`).sort();
+ expect(hits).toEqual([
+ 'view/layout-without-binding @ views[0].listViews.flatter.tree',
+ 'view/layout-without-binding @ views[0].listViews.recent.timeline',
+ 'view/layout-without-binding @ views[0].listViews.sites.map',
+ 'view/tree-without-parent-field @ views[0].listViews.flat.tree.parentField',
+ 'view/tree-without-parent-field @ views[0].listViews.flatter.tree.parentField',
+ ]);
+ });
+
+ it(`the bound stack passes \`${command}\``, () => {
+ const { errors, advisories } = splitBySeverity(runAuthoringRules(command, { normalized: clean as never }));
+ expect([...errors, ...advisories].filter((f) => BINDING_RULES.includes(f.rule))).toEqual([]);
+ });
+ }
+});

packages/lint/src/validate-functional-completeness.ts

@@ -103,15 +103,38 @@ export function validateFunctionalCompleteness(stack: unknown): FunctionalComple
  // ── List views: views[] containers → list / listViews.* ────────────────
  // (Form views carry no layout-binding contract; field completeness inside
  // objects is already covered above.)
+ //
+ // The predicate takes the BOUND OBJECT as its optional second argument —
+ // the `tree` parent-pointer rule needs the object's fields to ask whether
+ // the renderer could auto-detect one. This is wiring only: the object is
+ // looked up by name in `stack.objects` (already normalized to an array, so
+ // both authorable spellings arrive with a `name`), resolved in the order
+ // the sibling reference-integrity rules use — a list view's own
+ // `data.object` retarget first (ADR-0047), then the container's binding —
+ // and handed over. Absent from the stack, nothing is handed and the
+ // predicate stays silent on that rule; the dangling `data.object` itself
+ // is `validate-object-references`' finding.
+ const objectsByName = new Map(entriesOf(stack.objects).map((o) => [o.name, o.def]));
+ const strName = (v: unknown): string | undefined => (typeof v === 'string' && v ? v : undefined);
+ const boundObjectOf = (view: AnyRec, container: AnyRec): AnyRec | undefined => {
+ const own = isRec(view.data) ? strName(view.data.object) : undefined;
+ const name = own ?? strName(container.objectName) ?? strName(container.object);
+ return name ? objectsByName.get(name) : undefined;
+ };
  for (const [vi, container] of entriesOf(stack.views).entries()) {
  const where = container.def.object ? `view container "${container.name}"` : `view container [${vi}]`;
  if (isRec(container.def.list)) {
- push(out, checkViewCompleteness(container.def.list), `${where} › list`, `views[${vi}].list`);
+ push(
+ out,
+ checkViewCompleteness(container.def.list, boundObjectOf(container.def.list, container.def)),
+ `${where} › list`,
+ `views[${vi}].list`,
+ );
  }
  for (const lv of entriesOf(container.def.listViews)) {
  push(
  out,
- checkViewCompleteness(lv.def),
+ checkViewCompleteness(lv.def, boundObjectOf(lv.def, container.def)),
  `${where} › listViews.${lv.name}`,
  `views[${vi}].listViews${lv.key}`,
  );

packages/spec/api-surface/kernel.json

@@ -442,6 +442,7 @@
  "UpgradeSnapshotParsed (type)",
  "UpgradeSnapshotSchema (const)",
  "VIEW_LAYOUT_WITHOUT_BINDING (const)",
+ "VIEW_TREE_WITHOUT_PARENT_FIELD (const)",
  "ValidationError (type)",
  "ValidationErrorSchema (const)",
  "ValidationResult (type)",

packages/spec/export-origins/kernel.json

@@ -442,6 +442,7 @@
  "UpgradeSnapshotParsed": "src/kernel/package-upgrade.zod.ts#UpgradeSnapshotParsed (type)",
  "UpgradeSnapshotSchema": "src/kernel/package-upgrade.zod.ts#UpgradeSnapshotSchema (const)",
  "VIEW_LAYOUT_WITHOUT_BINDING": "src/kernel/functional-completeness.ts#VIEW_LAYOUT_WITHOUT_BINDING (const)",
+ "VIEW_TREE_WITHOUT_PARENT_FIELD": "src/kernel/functional-completeness.ts#VIEW_TREE_WITHOUT_PARENT_FIELD (const)",
  "ValidationError": "src/kernel/plugin-validator.zod.ts#ValidationError (type)",
  "ValidationErrorSchema": "src/kernel/plugin-validator.zod.ts#ValidationErrorSchema (const)",
  "ValidationResult": "src/kernel/plugin-validator.zod.ts#ValidationResult (type)",

.changeset/view-binding-blocks-complete.md

@@ -0,0 +1,37 @@
+---
+'@objectstack/spec': minor
+'@objectstack/lint': patch
+---
+
+`view/layout-without-binding` now covers every view type that carries a binding block, and a new `view/tree-without-parent-field` rule catches the silently flat tree
+
+`checkViewCompleteness`'s `VIEW_BINDING_BLOCKS` table named `kanban` / `calendar` / `gantt` only, while
+`ListViewSchema.type` has six members with a type-specific binding block. The other three fell through
+the same trapdoor the rule exists to close: objectui's ListView adapter falls back to literal field
+names (`timeline` → `startDateField || 'created_at'`, `titleField || 'name'`; `map` →
+`locationField || 'location'`; `tree` → `labelField || titleField || 'name'`), so a view authored
+without its block rendered empty — `timeline` drops every row whose start date fails to parse —
+while `os validate --json` reported `warnings: []` and `valid: true`. Measured both ways: deleting a
+`timeline` block was silent, deleting the sibling `gantt` block warned as designed.
+
+- The table now names all six. Each new entry carries a `fix` hint naming the keys that make the block
+ a binding (`timeline`'s two schema-required keys; either coordinate form for `map`; `parentField` +
+ `labelField` for `tree`). Severity stays `warning` (ADR-0078 §1 — the view degrades, it does not die).
+- `map` is read for its coordinate binding, not merely for block presence: `ListMapConfigSchema` requires
+ no key, so a `map` block declaring neither `locationField` nor the `latitudeField`/`longitudeField`
+ pair is the same unbound view with braces and is warned about at `map.locationField`.
+- **New rule `view/tree-without-parent-field`** (warning, path `tree.parentField`): a `type: 'tree'` view
+ with no declared `parentField` on an object that carries neither a `tree` field nor a
+ `lookup`/`master_detail` back to itself renders FLAT — every record at depth 0, a correct-looking table
+ whose expand slot never opens. Every `TreeConfigSchema` key is optional, so `tree: {}` satisfies the
+ block check and still renders flat; this rule mirrors objectui's `detectParentField` exactly, so a
+ view the renderer resolves by auto-detection is never warned about.
+- `checkViewCompleteness(view, boundObject?)` takes the bound object definition as an optional second
+ argument (additive; one-argument callers are unchanged and the tree rule stays silent for them).
+ `@objectstack/lint`'s `validate-functional-completeness` resolves the object by name from
+ `stack.objects` — the list view's own `data.object` first, then the container's binding — and hands
+ it over; no rule logic moved into lint.
+- `gallery` is measured (`titleField || 'name'`) and deliberately not added: its schema has no binding key
+ to demand. `page` stays deliberately absent (a `page` view refuses at parse via `checkListViewPageMount`).
+
+Under `os validate --strict` the new warnings are failures, as every warning in this family is.

packages/lint/src/validate-functional-completeness.test.ts

@@ -15,6 +15,7 @@
 
 import { describe, expect, it } from 'vitest';
 
+import { runAuthoringRules, splitBySeverity } from './authoring-rules.js';
 import { validateFunctionalCompleteness } from './validate-functional-completeness.js';
 
 const bareSummary = { type: 'summary' };
@@ -85,6 +86,52 @@ describe('validateFunctionalCompleteness — the walk', () => {
  expect(findings.every((f) => f.severity === 'warning')).toBe(true);
  });
 
+ it('hands the bound object to the view predicate — the tree parent pointer resolves against `stack.objects`', () => {
+ // The predicate's tree rule needs the object's fields; this proves the
+ // walk actually delivers them, in every resolution the sibling
+ // reference-integrity rules use. Array-form objects, container binding:
+ const flat = validateFunctionalCompleteness({
+ objects: [{ name: 'unit', fields: [{ name: 'name', type: 'text' }] }],
+ views: [{ object: 'unit', listViews: { org: { type: 'tree', tree: {} } } }],
+ });
+ expect(flat.map((f) => [f.rule, f.severity, f.path])).toEqual([
+ ['view/tree-without-parent-field', 'warning', 'views[0].listViews.org.tree.parentField'],
+ ]);
+ expect(flat[0].where).toMatch(/› listViews\.org$/);
+
+ // Map-form objects (the walk injects `name`), a self-lookup → silent.
+ expect(validateFunctionalCompleteness({
+ objects: { unit: { fields: { parent: { type: 'lookup', reference: 'unit' } } } },
+ views: [{ object: 'unit', listViews: { org: { type: 'tree', tree: {} } } }],
+ })).toEqual([]);
+
+ // The container's default `list` slot is handed the object too.
+ expect(validateFunctionalCompleteness({
+ objects: [{ name: 'unit', fields: [] }],
+ views: [{ object: 'unit', list: { type: 'tree', tree: {} } }],
+ }).map((f) => f.path)).toEqual(['views[0].list.tree.parentField']);
+
+ // A list view's own `data.object` retargets the lookup (ADR-0047):
+ // `cat` carries a `tree` field, so the view bound to it is clean even
+ // though the container's object has nothing to detect.
+ expect(validateFunctionalCompleteness({
+ objects: [
+ { name: 'unit', fields: [] },
+ { name: 'cat', fields: [{ name: 'parent', type: 'tree' }] },
+ ],
+ views: [{
+ object: 'unit',
+ listViews: { org: { type: 'tree', tree: {}, data: { provider: 'object', object: 'cat' } } },
+ }],
+ })).toEqual([]);
+
+ // An object the stack does not declare: nothing is handed over and the
+ // tree rule stays silent — `validate-object-references` owns that miss.
+ expect(validateFunctionalCompleteness({
+ views: [{ object: 'ghost', listViews: { org: { type: 'tree', tree: {} } } }],
+ })).toEqual([]);
+ });
+
  it('walks webhooks in both spellings', () => {
  expect(validateFunctionalCompleteness({
  webhooks: [{ name: 'notify', url: 'https://x' }],
@@ -128,3 +175,72 @@ describe('validateFunctionalCompleteness — the walk', () => {
  }
  });
 });
+
+/**
+ * The card's acceptance criteria, pinned end-to-end through the rule table
+ * (the #14108 precedent): `timeline` / `map` / `tree` without their binding
+ * block must produce a diagnostic on `os validate` (and `os build`), and a
+ * `tree` view bound to an object with no self-reference must produce one
+ * whether its block is empty or absent. The clean twins prove the fixtures
+ * fail for the right reason.
+ */
+describe('#14106 acceptance — timeline / map / tree bindings reach `validate` AND `build`', () => {
+ const object = {
+ name: 'duly_task',
+ fields: {
+ subject: { type: 'text' },
+ last_update_at: { type: 'datetime' },
+ site: { type: 'text' },
+ },
+ };
+ const repro = {
+ objects: [object],
+ views: [{
+ object: 'duly_task',
+ listViews: {
+ recent: { type: 'timeline', columns: ['subject'] },
+ sites: { type: 'map', columns: ['subject'] },
+ flat: { type: 'tree', tree: {}, columns: ['subject'] },
+ flatter: { type: 'tree', columns: ['subject'] },
+ },
+ }],
+ };
+ const clean = {
+ objects: [{
+ ...object,
+ fields: { ...object.fields, parent: { type: 'lookup', reference: 'duly_task' } },
+ }],
+ views: [{
+ object: 'duly_task',
+ listViews: {
+ recent: {
+ type: 'timeline', columns: ['subject'],
+ timeline: { startDateField: 'last_update_at', titleField: 'subject' },
+ },
+ sites: { type: 'map', columns: ['subject'], map: { locationField: 'site' } },
+ flat: { type: 'tree', tree: {}, columns: ['subject'] },
+ declared: { type: 'tree', tree: { parentField: 'parent' }, columns: ['subject'] },
+ },
+ }],
+ };
+ const BINDING_RULES = ['view/layout-without-binding', 'view/tree-without-parent-field'];
+
+ for (const command of ['validate', 'build'] as const) {
+ it(`the measured repro is diagnosed by \`${command}\``, () => {
+ const { advisories } = splitBySeverity(runAuthoringRules(command, { normalized: repro as never }));
+ const hits = advisories.filter((f) => BINDING_RULES.includes(f.rule)).map((f) => `${f.rule} @ ${f.path}`).sort();
+ expect(hits).toEqual([
+ 'view/layout-without-binding @ views[0].listViews.flatter.tree',
+ 'view/layout-without-binding @ views[0].listViews.recent.timeline',
+ 'view/layout-without-binding @ views[0].listViews.sites.map',
+ 'view/tree-without-parent-field @ views[0].listViews.flat.tree.parentField',
+ 'view/tree-without-parent-field @ views[0].listViews.flatter.tree.parentField',
+ ]);
+ });
+
+ it(`the bound stack passes \`${command}\``, () => {
+ const { errors, advisories } = splitBySeverity(runAuthoringRules(command, { normalized: clean as never }));
+ expect([...errors, ...advisories].filter((f) => BINDING_RULES.includes(f.rule))).toEqual([]);
+ });
+ }
+});

packages/lint/src/validate-functional-completeness.ts

@@ -103,15 +103,38 @@ export function validateFunctionalCompleteness(stack: unknown): FunctionalComple
  // ── List views: views[] containers → list / listViews.* ────────────────
  // (Form views carry no layout-binding contract; field completeness inside
  // objects is already covered above.)
+ //
+ // The predicate takes the BOUND OBJECT as its optional second argument —
+ // the `tree` parent-pointer rule needs the object's fields to ask whether
+ // the renderer could auto-detect one. This is wiring only: the object is
+ // looked up by name in `stack.objects` (already normalized to an array, so
+ // both authorable spellings arrive with a `name`), resolved in the order
+ // the sibling reference-integrity rules use — a list view's own
+ // `data.object` retarget first (ADR-0047), then the container's binding —
+ // and handed over. Absent from the stack, nothing is handed and the
+ // predicate stays silent on that rule; the dangling `data.object` itself
+ // is `validate-object-references`' finding.
+ const objectsByName = new Map(entriesOf(stack.objects).map((o) => [o.name, o.def]));
+ const strName = (v: unknown): string | undefined => (typeof v === 'string' && v ? v : undefined);
+ const boundObjectOf = (view: AnyRec, container: AnyRec): AnyRec | undefined => {
+ const own = isRec(view.data) ? strName(view.data.object) : undefined;
+ const name = own ?? strName(container.objectName) ?? strName(container.object);
+ return name ? objectsByName.get(name) : undefined;
+ };
  for (const [vi, container] of entriesOf(stack.views).entries()) {
  const where = container.def.object ? `view container "${container.name}"` : `view container [${vi}]`;
  if (isRec(container.def.list)) {
- push(out, checkViewCompleteness(container.def.list), `${where} › list`, `views[${vi}].list`);
+ push(
+ out,
+ checkViewCompleteness(container.def.list, boundObjectOf(container.def.list, container.def)),
+ `${where} › list`,
+ `views[${vi}].list`,
+ );
  }
  for (const lv of entriesOf(container.def.listViews)) {
  push(
  out,
- checkViewCompleteness(lv.def),
+ checkViewCompleteness(lv.def, boundObjectOf(lv.def, container.def)),
  `${where} › listViews.${lv.name}`,
  `views[${vi}].listViews${lv.key}`,
  );

packages/spec/api-surface/kernel.json

@@ -442,6 +442,7 @@
  "UpgradeSnapshotParsed (type)",
  "UpgradeSnapshotSchema (const)",
  "VIEW_LAYOUT_WITHOUT_BINDING (const)",
+ "VIEW_TREE_WITHOUT_PARENT_FIELD (const)",
  "ValidationError (type)",
  "ValidationErrorSchema (const)",
  "ValidationResult (type)",

packages/spec/export-origins/kernel.json

@@ -442,6 +442,7 @@
  "UpgradeSnapshotParsed": "src/kernel/package-upgrade.zod.ts#UpgradeSnapshotParsed (type)",
  "UpgradeSnapshotSchema": "src/kernel/package-upgrade.zod.ts#UpgradeSnapshotSchema (const)",
  "VIEW_LAYOUT_WITHOUT_BINDING": "src/kernel/functional-completeness.ts#VIEW_LAYOUT_WITHOUT_BINDING (const)",
+ "VIEW_TREE_WITHOUT_PARENT_FIELD": "src/kernel/functional-completeness.ts#VIEW_TREE_WITHOUT_PARENT_FIELD (const)",
  "ValidationError": "src/kernel/plugin-validator.zod.ts#ValidationError (type)",
  "ValidationErrorSchema": "src/kernel/plugin-validator.zod.ts#ValidationErrorSchema (const)",
  "ValidationResult": "src/kernel/plugin-validator.zod.ts#ValidationResult (type)",

.changeset/view-binding-blocks-complete.md

@@ -0,0 +1,37 @@
+---
+'@objectstack/spec': minor
+'@objectstack/lint': patch
+---
+
+`view/layout-without-binding` now covers every view type that carries a binding block, and a new `view/tree-without-parent-field` rule catches the silently flat tree
+
+`checkViewCompleteness`'s `VIEW_BINDING_BLOCKS` table named `kanban` / `calendar` / `gantt` only, while
+`ListViewSchema.type` has six members with a type-specific binding block. The other three fell through
+the same trapdoor the rule exists to close: objectui's ListView adapter falls back to literal field
+names (`timeline` → `startDateField || 'created_at'`, `titleField || 'name'`; `map` →
+`locationField || 'location'`; `tree` → `labelField || titleField || 'name'`), so a view authored
+without its block rendered empty — `timeline` drops every row whose start date fails to parse —
+while `os validate --json` reported `warnings: []` and `valid: true`. Measured both ways: deleting a
+`timeline` block was silent, deleting the sibling `gantt` block warned as designed.
+
+- The table now names all six. Each new entry carries a `fix` hint naming the keys that make the block
+ a binding (`timeline`'s two schema-required keys; either coordinate form for `map`; `parentField` +
+ `labelField` for `tree`). Severity stays `warning` (ADR-0078 §1 — the view degrades, it does not die).
+- `map` is read for its coordinate binding, not merely for block presence: `ListMapConfigSchema` requires
+ no key, so a `map` block declaring neither `locationField` nor the `latitudeField`/`longitudeField`
+ pair is the same unbound view with braces and is warned about at `map.locationField`.
+- **New rule `view/tree-without-parent-field`** (warning, path `tree.parentField`): a `type: 'tree'` view
+ with no declared `parentField` on an object that carries neither a `tree` field nor a
+ `lookup`/`master_detail` back to itself renders FLAT — every record at depth 0, a correct-looking table
+ whose expand slot never opens. Every `TreeConfigSchema` key is optional, so `tree: {}` satisfies the
+ block check and still renders flat; this rule mirrors objectui's `detectParentField` exactly, so a
+ view the renderer resolves by auto-detection is never warned about.
+- `checkViewCompleteness(view, boundObject?)` takes the bound object definition as an optional second
+ argument (additive; one-argument callers are unchanged and the tree rule stays silent for them).
+ `@objectstack/lint`'s `validate-functional-completeness` resolves the object by name from
+ `stack.objects` — the list view's own `data.object` first, then the container's binding — and hands
+ it over; no rule logic moved into lint.
+- `gallery` is measured (`titleField || 'name'`) and deliberately not added: its schema has no binding key
+ to demand. `page` stays deliberately absent (a `page` view refuses at parse via `checkListViewPageMount`).
+
+Under `os validate --strict` the new warnings are failures, as every warning in this family is.

packages/lint/src/validate-functional-completeness.test.ts

@@ -15,6 +15,7 @@
 
 import { describe, expect, it } from 'vitest';
 
+import { runAuthoringRules, splitBySeverity } from './authoring-rules.js';
 import { validateFunctionalCompleteness } from './validate-functional-completeness.js';
 
 const bareSummary = { type: 'summary' };
@@ -85,6 +86,52 @@ describe('validateFunctionalCompleteness — the walk', () => {
  expect(findings.every((f) => f.severity === 'warning')).toBe(true);
  });
 
+ it('hands the bound object to the view predicate — the tree parent pointer resolves against `stack.objects`', () => {
+ // The predicate's tree rule needs the object's fields; this proves the
+ // walk actually delivers them, in every resolution the sibling
+ // reference-integrity rules use. Array-form objects, container binding:
+ const flat = validateFunctionalCompleteness({
+ objects: [{ name: 'unit', fields: [{ name: 'name', type: 'text' }] }],
+ views: [{ object: 'unit', listViews: { org: { type: 'tree', tree: {} } } }],
+ });
+ expect(flat.map((f) => [f.rule, f.severity, f.path])).toEqual([
+ ['view/tree-without-parent-field', 'warning', 'views[0].listViews.org.tree.parentField'],
+ ]);
+ expect(flat[0].where).toMatch(/› listViews\.org$/);
+
+ // Map-form objects (the walk injects `name`), a self-lookup → silent.
+ expect(validateFunctionalCompleteness({
+ objects: { unit: { fields: { parent: { type: 'lookup', reference: 'unit' } } } },
+ views: [{ object: 'unit', listViews: { org: { type: 'tree', tree: {} } } }],
+ })).toEqual([]);
+
+ // The container's default `list` slot is handed the object too.
+ expect(validateFunctionalCompleteness({
+ objects: [{ name: 'unit', fields: [] }],
+ views: [{ object: 'unit', list: { type: 'tree', tree: {} } }],
+ }).map((f) => f.path)).toEqual(['views[0].list.tree.parentField']);
+
+ // A list view's own `data.object` retargets the lookup (ADR-0047):
+ // `cat` carries a `tree` field, so the view bound to it is clean even
+ // though the container's object has nothing to detect.
+ expect(validateFunctionalCompleteness({
+ objects: [
+ { name: 'unit', fields: [] },
+ { name: 'cat', fields: [{ name: 'parent', type: 'tree' }] },
+ ],
+ views: [{
+ object: 'unit',
+ listViews: { org: { type: 'tree', tree: {}, data: { provider: 'object', object: 'cat' } } },
+ }],
+ })).toEqual([]);
+
+ // An object the stack does not declare: nothing is handed over and the
+ // tree rule stays silent — `validate-object-references` owns that miss.
+ expect(validateFunctionalCompleteness({
+ views: [{ object: 'ghost', listViews: { org: { type: 'tree', tree: {} } } }],
+ })).toEqual([]);
+ });
+
  it('walks webhooks in both spellings', () => {
  expect(validateFunctionalCompleteness({
  webhooks: [{ name: 'notify', url: 'https://x' }],
@@ -128,3 +175,72 @@ describe('validateFunctionalCompleteness — the walk', () => {
  }
  });
 });
+
+/**
+ * The card's acceptance criteria, pinned end-to-end through the rule table
+ * (the #14108 precedent): `timeline` / `map` / `tree` without their binding
+ * block must produce a diagnostic on `os validate` (and `os build`), and a
+ * `tree` view bound to an object with no self-reference must produce one
+ * whether its block is empty or absent. The clean twins prove the fixtures
+ * fail for the right reason.
+ */
+describe('#14106 acceptance — timeline / map / tree bindings reach `validate` AND `build`', () => {
+ const object = {
+ name: 'duly_task',
+ fields: {
+ subject: { type: 'text' },
+ last_update_at: { type: 'datetime' },
+ site: { type: 'text' },
+ },
+ };
+ const repro = {
+ objects: [object],
+ views: [{
+ object: 'duly_task',
+ listViews: {
+ recent: { type: 'timeline', columns: ['subject'] },
+ sites: { type: 'map', columns: ['subject'] },
+ flat: { type: 'tree', tree: {}, columns: ['subject'] },
+ flatter: { type: 'tree', columns: ['subject'] },
+ },
+ }],
+ };
+ const clean = {
+ objects: [{
+ ...object,
+ fields: { ...object.fields, parent: { type: 'lookup', reference: 'duly_task' } },
+ }],
+ views: [{
+ object: 'duly_task',
+ listViews: {
+ recent: {
+ type: 'timeline', columns: ['subject'],
+ timeline: { startDateField: 'last_update_at', titleField: 'subject' },
+ },
+ sites: { type: 'map', columns: ['subject'], map: { locationField: 'site' } },
+ flat: { type: 'tree', tree: {}, columns: ['subject'] },
+ declared: { type: 'tree', tree: { parentField: 'parent' }, columns: ['subject'] },
+ },
+ }],
+ };
+ const BINDING_RULES = ['view/layout-without-binding', 'view/tree-without-parent-field'];
+
+ for (const command of ['validate', 'build'] as const) {
+ it(`the measured repro is diagnosed by \`${command}\``, () => {
+ const { advisories } = splitBySeverity(runAuthoringRules(command, { normalized: repro as never }));
+ const hits = advisories.filter((f) => BINDING_RULES.includes(f.rule)).map((f) => `${f.rule} @ ${f.path}`).sort();
+ expect(hits).toEqual([
+ 'view/layout-without-binding @ views[0].listViews.flatter.tree',
+ 'view/layout-without-binding @ views[0].listViews.recent.timeline',
+ 'view/layout-without-binding @ views[0].listViews.sites.map',
+ 'view/tree-without-parent-field @ views[0].listViews.flat.tree.parentField',
+ 'view/tree-without-parent-field @ views[0].listViews.flatter.tree.parentField',
+ ]);
+ });
+
+ it(`the bound stack passes \`${command}\``, () => {
+ const { errors, advisories } = splitBySeverity(runAuthoringRules(command, { normalized: clean as never }));
+ expect([...errors, ...advisories].filter((f) => BINDING_RULES.includes(f.rule))).toEqual([]);
+ });
+ }
+});

packages/lint/src/validate-functional-completeness.ts

@@ -103,15 +103,38 @@ export function validateFunctionalCompleteness(stack: unknown): FunctionalComple
  // ── List views: views[] containers → list / listViews.* ────────────────
  // (Form views carry no layout-binding contract; field completeness inside
  // objects is already covered above.)
+ //
+ // The predicate takes the BOUND OBJECT as its optional second argument —
+ // the `tree` parent-pointer rule needs the object's fields to ask whether
+ // the renderer could auto-detect one. This is wiring only: the object is
+ // looked up by name in `stack.objects` (already normalized to an array, so
+ // both authorable spellings arrive with a `name`), resolved in the order
+ // the sibling reference-integrity rules use — a list view's own
+ // `data.object` retarget first (ADR-0047), then the container's binding —
+ // and handed over. Absent from the stack, nothing is handed and the
+ // predicate stays silent on that rule; the dangling `data.object` itself
+ // is `validate-object-references`' finding.
+ const objectsByName = new Map(entriesOf(stack.objects).map((o) => [o.name, o.def]));
+ const strName = (v: unknown): string | undefined => (typeof v === 'string' && v ? v : undefined);
+ const boundObjectOf = (view: AnyRec, container: AnyRec): AnyRec | undefined => {
+ const own = isRec(view.data) ? strName(view.data.object) : undefined;
+ const name = own ?? strName(container.objectName) ?? strName(container.object);
+ return name ? objectsByName.get(name) : undefined;
+ };
  for (const [vi, container] of entriesOf(stack.views).entries()) {
  const where = container.def.object ? `view container "${container.name}"` : `view container [${vi}]`;
  if (isRec(container.def.list)) {
- push(out, checkViewCompleteness(container.def.list), `${where} › list`, `views[${vi}].list`);
+ push(
+ out,
+ checkViewCompleteness(container.def.list, boundObjectOf(container.def.list, container.def)),
+ `${where} › list`,
+ `views[${vi}].list`,
+ );
  }
  for (const lv of entriesOf(container.def.listViews)) {
  push(
  out,
- checkViewCompleteness(lv.def),
+ checkViewCompleteness(lv.def, boundObjectOf(lv.def, container.def)),
  `${where} › listViews.${lv.name}`,
  `views[${vi}].listViews${lv.key}`,
  );

packages/spec/api-surface/kernel.json

@@ -442,6 +442,7 @@
  "UpgradeSnapshotParsed (type)",
  "UpgradeSnapshotSchema (const)",
  "VIEW_LAYOUT_WITHOUT_BINDING (const)",
+ "VIEW_TREE_WITHOUT_PARENT_FIELD (const)",
  "ValidationError (type)",
  "ValidationErrorSchema (const)",
  "ValidationResult (type)",

packages/spec/export-origins/kernel.json

@@ -442,6 +442,7 @@
  "UpgradeSnapshotParsed": "src/kernel/package-upgrade.zod.ts#UpgradeSnapshotParsed (type)",
  "UpgradeSnapshotSchema": "src/kernel/package-upgrade.zod.ts#UpgradeSnapshotSchema (const)",
  "VIEW_LAYOUT_WITHOUT_BINDING": "src/kernel/functional-completeness.ts#VIEW_LAYOUT_WITHOUT_BINDING (const)",
+ "VIEW_TREE_WITHOUT_PARENT_FIELD": "src/kernel/functional-completeness.ts#VIEW_TREE_WITHOUT_PARENT_FIELD (const)",
  "ValidationError": "src/kernel/plugin-validator.zod.ts#ValidationError (type)",
  "ValidationErrorSchema": "src/kernel/plugin-validator.zod.ts#ValidationErrorSchema (const)",
  "ValidationResult": "src/kernel/plugin-validator.zod.ts#ValidationResult (type)",

.changeset/view-binding-blocks-complete.md

@@ -0,0 +1,37 @@
+---
+'@objectstack/spec': minor
+'@objectstack/lint': patch
+---
+
+`view/layout-without-binding` now covers every view type that carries a binding block, and a new `view/tree-without-parent-field` rule catches the silently flat tree
+
+`checkViewCompleteness`'s `VIEW_BINDING_BLOCKS` table named `kanban` / `calendar` / `gantt` only, while
+`ListViewSchema.type` has six members with a type-specific binding block. The other three fell through
+the same trapdoor the rule exists to close: objectui's ListView adapter falls back to literal field
+names (`timeline` → `startDateField || 'created_at'`, `titleField || 'name'`; `map` →
+`locationField || 'location'`; `tree` → `labelField || titleField || 'name'`), so a view authored
+without its block rendered empty — `timeline` drops every row whose start date fails to parse —
+while `os validate --json` reported `warnings: []` and `valid: true`. Measured both ways: deleting a
+`timeline` block was silent, deleting the sibling `gantt` block warned as designed.
+
+- The table now names all six. Each new entry carries a `fix` hint naming the keys that make the block
+ a binding (`timeline`'s two schema-required keys; either coordinate form for `map`; `parentField` +
+ `labelField` for `tree`). Severity stays `warning` (ADR-0078 §1 — the view degrades, it does not die).
+- `map` is read for its coordinate binding, not merely for block presence: `ListMapConfigSchema` requires
+ no key, so a `map` block declaring neither `locationField` nor the `latitudeField`/`longitudeField`
+ pair is the same unbound view with braces and is warned about at `map.locationField`.
+- **New rule `view/tree-without-parent-field`** (warning, path `tree.parentField`): a `type: 'tree'` view
+ with no declared `parentField` on an object that carries neither a `tree` field nor a
+ `lookup`/`master_detail` back to itself renders FLAT — every record at depth 0, a correct-looking table
+ whose expand slot never opens. Every `TreeConfigSchema` key is optional, so `tree: {}` satisfies the
+ block check and still renders flat; this rule mirrors objectui's `detectParentField` exactly, so a
+ view the renderer resolves by auto-detection is never warned about.
+- `checkViewCompleteness(view, boundObject?)` takes the bound object definition as an optional second
+ argument (additive; one-argument callers are unchanged and the tree rule stays silent for them).
+ `@objectstack/lint`'s `validate-functional-completeness` resolves the object by name from
+ `stack.objects` — the list view's own `data.object` first, then the container's binding — and hands
+ it over; no rule logic moved into lint.
+- `gallery` is measured (`titleField || 'name'`) and deliberately not added: its schema has no binding key
+ to demand. `page` stays deliberately absent (a `page` view refuses at parse via `checkListViewPageMount`).
+
+Under `os validate --strict` the new warnings are failures, as every warning in this family is.

packages/lint/src/validate-functional-completeness.test.ts

@@ -15,6 +15,7 @@
 
 import { describe, expect, it } from 'vitest';
 
+import { runAuthoringRules, splitBySeverity } from './authoring-rules.js';
 import { validateFunctionalCompleteness } from './validate-functional-completeness.js';
 
 const bareSummary = { type: 'summary' };
@@ -85,6 +86,52 @@ describe('validateFunctionalCompleteness — the walk', () => {
  expect(findings.every((f) => f.severity === 'warning')).toBe(true);
  });
 
+ it('hands the bound object to the view predicate — the tree parent pointer resolves against `stack.objects`', () => {
+ // The predicate's tree rule needs the object's fields; this proves the
+ // walk actually delivers them, in every resolution the sibling
+ // reference-integrity rules use. Array-form objects, container binding:
+ const flat = validateFunctionalCompleteness({
+ objects: [{ name: 'unit', fields: [{ name: 'name', type: 'text' }] }],
+ views: [{ object: 'unit', listViews: { org: { type: 'tree', tree: {} } } }],
+ });
+ expect(flat.map((f) => [f.rule, f.severity, f.path])).toEqual([
+ ['view/tree-without-parent-field', 'warning', 'views[0].listViews.org.tree.parentField'],
+ ]);
+ expect(flat[0].where).toMatch(/› listViews\.org$/);
+
+ // Map-form objects (the walk injects `name`), a self-lookup → silent.
+ expect(validateFunctionalCompleteness({
+ objects: { unit: { fields: { parent: { type: 'lookup', reference: 'unit' } } } },
+ views: [{ object: 'unit', listViews: { org: { type: 'tree', tree: {} } } }],
+ })).toEqual([]);
+
+ // The container's default `list` slot is handed the object too.
+ expect(validateFunctionalCompleteness({
+ objects: [{ name: 'unit', fields: [] }],
+ views: [{ object: 'unit', list: { type: 'tree', tree: {} } }],
+ }).map((f) => f.path)).toEqual(['views[0].list.tree.parentField']);
+
+ // A list view's own `data.object` retargets the lookup (ADR-0047):
+ // `cat` carries a `tree` field, so the view bound to it is clean even
+ // though the container's object has nothing to detect.
+ expect(validateFunctionalCompleteness({
+ objects: [
+ { name: 'unit', fields: [] },
+ { name: 'cat', fields: [{ name: 'parent', type: 'tree' }] },
+ ],
+ views: [{
+ object: 'unit',
+ listViews: { org: { type: 'tree', tree: {}, data: { provider: 'object', object: 'cat' } } },
+ }],
+ })).toEqual([]);
+
+ // An object the stack does not declare: nothing is handed over and the
+ // tree rule stays silent — `validate-object-references` owns that miss.
+ expect(validateFunctionalCompleteness({
+ views: [{ object: 'ghost', listViews: { org: { type: 'tree', tree: {} } } }],
+ })).toEqual([]);
+ });
+
  it('walks webhooks in both spellings', () => {
  expect(validateFunctionalCompleteness({
  webhooks: [{ name: 'notify', url: 'https://x' }],
@@ -128,3 +175,72 @@ describe('validateFunctionalCompleteness — the walk', () => {
  }
  });
 });
+
+/**
+ * The card's acceptance criteria, pinned end-to-end through the rule table
+ * (the #14108 precedent): `timeline` / `map` / `tree` without their binding
+ * block must produce a diagnostic on `os validate` (and `os build`), and a
+ * `tree` view bound to an object with no self-reference must produce one
+ * whether its block is empty or absent. The clean twins prove the fixtures
+ * fail for the right reason.
+ */
+describe('#14106 acceptance — timeline / map / tree bindings reach `validate` AND `build`', () => {
+ const object = {
+ name: 'duly_task',
+ fields: {
+ subject: { type: 'text' },
+ last_update_at: { type: 'datetime' },
+ site: { type: 'text' },
+ },
+ };
+ const repro = {
+ objects: [object],
+ views: [{
+ object: 'duly_task',
+ listViews: {
+ recent: { type: 'timeline', columns: ['subject'] },
+ sites: { type: 'map', columns: ['subject'] },
+ flat: { type: 'tree', tree: {}, columns: ['subject'] },
+ flatter: { type: 'tree', columns: ['subject'] },
+ },
+ }],
+ };
+ const clean = {
+ objects: [{
+ ...object,
+ fields: { ...object.fields, parent: { type: 'lookup', reference: 'duly_task' } },
+ }],
+ views: [{
+ object: 'duly_task',
+ listViews: {
+ recent: {
+ type: 'timeline', columns: ['subject'],
+ timeline: { startDateField: 'last_update_at', titleField: 'subject' },
+ },
+ sites: { type: 'map', columns: ['subject'], map: { locationField: 'site' } },
+ flat: { type: 'tree', tree: {}, columns: ['subject'] },
+ declared: { type: 'tree', tree: { parentField: 'parent' }, columns: ['subject'] },
+ },
+ }],
+ };
+ const BINDING_RULES = ['view/layout-without-binding', 'view/tree-without-parent-field'];
+
+ for (const command of ['validate', 'build'] as const) {
+ it(`the measured repro is diagnosed by \`${command}\``, () => {
+ const { advisories } = splitBySeverity(runAuthoringRules(command, { normalized: repro as never }));
+ const hits = advisories.filter((f) => BINDING_RULES.includes(f.rule)).map((f) => `${f.rule} @ ${f.path}`).sort();
+ expect(hits).toEqual([
+ 'view/layout-without-binding @ views[0].listViews.flatter.tree',
+ 'view/layout-without-binding @ views[0].listViews.recent.timeline',
+ 'view/layout-without-binding @ views[0].listViews.sites.map',
+ 'view/tree-without-parent-field @ views[0].listViews.flat.tree.parentField',
+ 'view/tree-without-parent-field @ views[0].listViews.flatter.tree.parentField',
+ ]);
+ });
+
+ it(`the bound stack passes \`${command}\``, () => {
+ const { errors, advisories } = splitBySeverity(runAuthoringRules(command, { normalized: clean as never }));
+ expect([...errors, ...advisories].filter((f) => BINDING_RULES.includes(f.rule))).toEqual([]);
+ });
+ }
+});

packages/lint/src/validate-functional-completeness.ts

@@ -103,15 +103,38 @@ export function validateFunctionalCompleteness(stack: unknown): FunctionalComple
  // ── List views: views[] containers → list / listViews.* ────────────────
  // (Form views carry no layout-binding contract; field completeness inside
  // objects is already covered above.)
+ //
+ // The predicate takes the BOUND OBJECT as its optional second argument —
+ // the `tree` parent-pointer rule needs the object's fields to ask whether
+ // the renderer could auto-detect one. This is wiring only: the object is
+ // looked up by name in `stack.objects` (already normalized to an array, so
+ // both authorable spellings arrive with a `name`), resolved in the order
+ // the sibling reference-integrity rules use — a list view's own
+ // `data.object` retarget first (ADR-0047), then the container's binding —
+ // and handed over. Absent from the stack, nothing is handed and the
+ // predicate stays silent on that rule; the dangling `data.object` itself
+ // is `validate-object-references`' finding.
+ const objectsByName = new Map(entriesOf(stack.objects).map((o) => [o.name, o.def]));
+ const strName = (v: unknown): string | undefined => (typeof v === 'string' && v ? v : undefined);
+ const boundObjectOf = (view: AnyRec, container: AnyRec): AnyRec | undefined => {
+ const own = isRec(view.data) ? strName(view.data.object) : undefined;
+ const name = own ?? strName(container.objectName) ?? strName(container.object);
+ return name ? objectsByName.get(name) : undefined;
+ };
  for (const [vi, container] of entriesOf(stack.views).entries()) {
  const where = container.def.object ? `view container "${container.name}"` : `view container [${vi}]`;
  if (isRec(container.def.list)) {
- push(out, checkViewCompleteness(container.def.list), `${where} › list`, `views[${vi}].list`);
+ push(
+ out,
+ checkViewCompleteness(container.def.list, boundObjectOf(container.def.list, container.def)),
+ `${where} › list`,
+ `views[${vi}].list`,
+ );
  }
  for (const lv of entriesOf(container.def.listViews)) {
  push(
  out,
- checkViewCompleteness(lv.def),
+ checkViewCompleteness(lv.def, boundObjectOf(lv.def, container.def)),
  `${where} › listViews.${lv.name}`,
  `views[${vi}].listViews${lv.key}`,
  );

packages/spec/api-surface/kernel.json

@@ -442,6 +442,7 @@
  "UpgradeSnapshotParsed (type)",
  "UpgradeSnapshotSchema (const)",
  "VIEW_LAYOUT_WITHOUT_BINDING (const)",
+ "VIEW_TREE_WITHOUT_PARENT_FIELD (const)",
  "ValidationError (type)",
  "ValidationErrorSchema (const)",
  "ValidationResult (type)",

packages/spec/export-origins/kernel.json

@@ -442,6 +442,7 @@
  "UpgradeSnapshotParsed": "src/kernel/package-upgrade.zod.ts#UpgradeSnapshotParsed (type)",
  "UpgradeSnapshotSchema": "src/kernel/package-upgrade.zod.ts#UpgradeSnapshotSchema (const)",
  "VIEW_LAYOUT_WITHOUT_BINDING": "src/kernel/functional-completeness.ts#VIEW_LAYOUT_WITHOUT_BINDING (const)",
+ "VIEW_TREE_WITHOUT_PARENT_FIELD": "src/kernel/functional-completeness.ts#VIEW_TREE_WITHOUT_PARENT_FIELD (const)",
  "ValidationError": "src/kernel/plugin-validator.zod.ts#ValidationError (type)",
  "ValidationErrorSchema": "src/kernel/plugin-validator.zod.ts#ValidationErrorSchema (const)",
  "ValidationResult": "src/kernel/plugin-validator.zod.ts#ValidationResult (type)",

.changeset/view-binding-blocks-complete.md

@@ -0,0 +1,37 @@
+---
+'@objectstack/spec': minor
+'@objectstack/lint': patch
+---
+
+`view/layout-without-binding` now covers every view type that carries a binding block, and a new `view/tree-without-parent-field` rule catches the silently flat tree
+
+`checkViewCompleteness`'s `VIEW_BINDING_BLOCKS` table named `kanban` / `calendar` / `gantt` only, while
+`ListViewSchema.type` has six members with a type-specific binding block. The other three fell through
+the same trapdoor the rule exists to close: objectui's ListView adapter falls back to literal field
+names (`timeline` → `startDateField || 'created_at'`, `titleField || 'name'`; `map` →
+`locationField || 'location'`; `tree` → `labelField || titleField || 'name'`), so a view authored
+without its block rendered empty — `timeline` drops every row whose start date fails to parse —
+while `os validate --json` reported `warnings: []` and `valid: true`. Measured both ways: deleting a
+`timeline` block was silent, deleting the sibling `gantt` block warned as designed.
+
+- The table now names all six. Each new entry carries a `fix` hint naming the keys that make the block
+ a binding (`timeline`'s two schema-required keys; either coordinate form for `map`; `parentField` +
+ `labelField` for `tree`). Severity stays `warning` (ADR-0078 §1 — the view degrades, it does not die).
+- `map` is read for its coordinate binding, not merely for block presence: `ListMapConfigSchema` requires
+ no key, so a `map` block declaring neither `locationField` nor the `latitudeField`/`longitudeField`
+ pair is the same unbound view with braces and is warned about at `map.locationField`.
+- **New rule `view/tree-without-parent-field`** (warning, path `tree.parentField`): a `type: 'tree'` view
+ with no declared `parentField` on an object that carries neither a `tree` field nor a
+ `lookup`/`master_detail` back to itself renders FLAT — every record at depth 0, a correct-looking table
+ whose expand slot never opens. Every `TreeConfigSchema` key is optional, so `tree: {}` satisfies the
+ block check and still renders flat; this rule mirrors objectui's `detectParentField` exactly, so a
+ view the renderer resolves by auto-detection is never warned about.
+- `checkViewCompleteness(view, boundObject?)` takes the bound object definition as an optional second
+ argument (additive; one-argument callers are unchanged and the tree rule stays silent for them).
+ `@objectstack/lint`'s `validate-functional-completeness` resolves the object by name from
+ `stack.objects` — the list view's own `data.object` first, then the container's binding — and hands
+ it over; no rule logic moved into lint.
+- `gallery` is measured (`titleField || 'name'`) and deliberately not added: its schema has no binding key
+ to demand. `page` stays deliberately absent (a `page` view refuses at parse via `checkListViewPageMount`).
+
+Under `os validate --strict` the new warnings are failures, as every warning in this family is.

packages/lint/src/validate-functional-completeness.test.ts

@@ -15,6 +15,7 @@
 
 import { describe, expect, it } from 'vitest';
 
+import { runAuthoringRules, splitBySeverity } from './authoring-rules.js';
 import { validateFunctionalCompleteness } from './validate-functional-completeness.js';
 
 const bareSummary = { type: 'summary' };
@@ -85,6 +86,52 @@ describe('validateFunctionalCompleteness — the walk', () => {
  expect(findings.every((f) => f.severity === 'warning')).toBe(true);
  });
 
+ it('hands the bound object to the view predicate — the tree parent pointer resolves against `stack.objects`', () => {
+ // The predicate's tree rule needs the object's fields; this proves the
+ // walk actually delivers them, in every resolution the sibling
+ // reference-integrity rules use. Array-form objects, container binding:
+ const flat = validateFunctionalCompleteness({
+ objects: [{ name: 'unit', fields: [{ name: 'name', type: 'text' }] }],
+ views: [{ object: 'unit', listViews: { org: { type: 'tree', tree: {} } } }],
+ });
+ expect(flat.map((f) => [f.rule, f.severity, f.path])).toEqual([
+ ['view/tree-without-parent-field', 'warning', 'views[0].listViews.org.tree.parentField'],
+ ]);
+ expect(flat[0].where).toMatch(/› listViews\.org$/);
+
+ // Map-form objects (the walk injects `name`), a self-lookup → silent.
+ expect(validateFunctionalCompleteness({
+ objects: { unit: { fields: { parent: { type: 'lookup', reference: 'unit' } } } },
+ views: [{ object: 'unit', listViews: { org: { type: 'tree', tree: {} } } }],
+ })).toEqual([]);
+
+ // The container's default `list` slot is handed the object too.
+ expect(validateFunctionalCompleteness({
+ objects: [{ name: 'unit', fields: [] }],
+ views: [{ object: 'unit', list: { type: 'tree', tree: {} } }],
+ }).map((f) => f.path)).toEqual(['views[0].list.tree.parentField']);
+
+ // A list view's own `data.object` retargets the lookup (ADR-0047):
+ // `cat` carries a `tree` field, so the view bound to it is clean even
+ // though the container's object has nothing to detect.
+ expect(validateFunctionalCompleteness({
+ objects: [
+ { name: 'unit', fields: [] },
+ { name: 'cat', fields: [{ name: 'parent', type: 'tree' }] },
+ ],
+ views: [{
+ object: 'unit',
+ listViews: { org: { type: 'tree', tree: {}, data: { provider: 'object', object: 'cat' } } },
+ }],
+ })).toEqual([]);
+
+ // An object the stack does not declare: nothing is handed over and the
+ // tree rule stays silent — `validate-object-references` owns that miss.
+ expect(validateFunctionalCompleteness({
+ views: [{ object: 'ghost', listViews: { org: { type: 'tree', tree: {} } } }],
+ })).toEqual([]);
+ });
+
  it('walks webhooks in both spellings', () => {
  expect(validateFunctionalCompleteness({
  webhooks: [{ name: 'notify', url: 'https://x' }],
@@ -128,3 +175,72 @@ describe('validateFunctionalCompleteness — the walk', () => {
  }
  });
 });
+
+/**
+ * The card's acceptance criteria, pinned end-to-end through the rule table
+ * (the #14108 precedent): `timeline` / `map` / `tree` without their binding
+ * block must produce a diagnostic on `os validate` (and `os build`), and a
+ * `tree` view bound to an object with no self-reference must produce one
+ * whether its block is empty or absent. The clean twins prove the fixtures
+ * fail for the right reason.
+ */
+describe('#14106 acceptance — timeline / map / tree bindings reach `validate` AND `build`', () => {
+ const object = {
+ name: 'duly_task',
+ fields: {
+ subject: { type: 'text' },
+ last_update_at: { type: 'datetime' },
+ site: { type: 'text' },
+ },
+ };
+ const repro = {
+ objects: [object],
+ views: [{
+ object: 'duly_task',
+ listViews: {
+ recent: { type: 'timeline', columns: ['subject'] },
+ sites: { type: 'map', columns: ['subject'] },
+ flat: { type: 'tree', tree: {}, columns: ['subject'] },
+ flatter: { type: 'tree', columns: ['subject'] },
+ },
+ }],
+ };
+ const clean = {
+ objects: [{
+ ...object,
+ fields: { ...object.fields, parent: { type: 'lookup', reference: 'duly_task' } },
+ }],
+ views: [{
+ object: 'duly_task',
+ listViews: {
+ recent: {
+ type: 'timeline', columns: ['subject'],
+ timeline: { startDateField: 'last_update_at', titleField: 'subject' },
+ },
+ sites: { type: 'map', columns: ['subject'], map: { locationField: 'site' } },
+ flat: { type: 'tree', tree: {}, columns: ['subject'] },
+ declared: { type: 'tree', tree: { parentField: 'parent' }, columns: ['subject'] },
+ },
+ }],
+ };
+ const BINDING_RULES = ['view/layout-without-binding', 'view/tree-without-parent-field'];
+
+ for (const command of ['validate', 'build'] as const) {
+ it(`the measured repro is diagnosed by \`${command}\``, () => {
+ const { advisories } = splitBySeverity(runAuthoringRules(command, { normalized: repro as never }));
+ const hits = advisories.filter((f) => BINDING_RULES.includes(f.rule)).map((f) => `${f.rule} @ ${f.path}`).sort();
+ expect(hits).toEqual([
+ 'view/layout-without-binding @ views[0].listViews.flatter.tree',
+ 'view/layout-without-binding @ views[0].listViews.recent.timeline',
+ 'view/layout-without-binding @ views[0].listViews.sites.map',
+ 'view/tree-without-parent-field @ views[0].listViews.flat.tree.parentField',
+ 'view/tree-without-parent-field @ views[0].listViews.flatter.tree.parentField',
+ ]);
+ });
+
+ it(`the bound stack passes \`${command}\``, () => {
+ const { errors, advisories } = splitBySeverity(runAuthoringRules(command, { normalized: clean as never }));
+ expect([...errors, ...advisories].filter((f) => BINDING_RULES.includes(f.rule))).toEqual([]);
+ });
+ }
+});

packages/lint/src/validate-functional-completeness.ts

@@ -103,15 +103,38 @@ export function validateFunctionalCompleteness(stack: unknown): FunctionalComple
  // ── List views: views[] containers → list / listViews.* ────────────────
  // (Form views carry no layout-binding contract; field completeness inside
  // objects is already covered above.)
+ //
+ // The predicate takes the BOUND OBJECT as its optional second argument —
+ // the `tree` parent-pointer rule needs the object's fields to ask whether
+ // the renderer could auto-detect one. This is wiring only: the object is
+ // looked up by name in `stack.objects` (already normalized to an array, so
+ // both authorable spellings arrive with a `name`), resolved in the order
+ // the sibling reference-integrity rules use — a list view's own
+ // `data.object` retarget first (ADR-0047), then the container's binding —
+ // and handed over. Absent from the stack, nothing is handed and the
+ // predicate stays silent on that rule; the dangling `data.object` itself
+ // is `validate-object-references`' finding.
+ const objectsByName = new Map(entriesOf(stack.objects).map((o) => [o.name, o.def]));
+ const strName = (v: unknown): string | undefined => (typeof v === 'string' && v ? v : undefined);
+ const boundObjectOf = (view: AnyRec, container: AnyRec): AnyRec | undefined => {
+ const own = isRec(view.data) ? strName(view.data.object) : undefined;
+ const name = own ?? strName(container.objectName) ?? strName(container.object);
+ return name ? objectsByName.get(name) : undefined;
+ };
  for (const [vi, container] of entriesOf(stack.views).entries()) {
  const where = container.def.object ? `view container "${container.name}"` : `view container [${vi}]`;
  if (isRec(container.def.list)) {
- push(out, checkViewCompleteness(container.def.list), `${where} › list`, `views[${vi}].list`);
+ push(
+ out,
+ checkViewCompleteness(container.def.list, boundObjectOf(container.def.list, container.def)),
+ `${where} › list`,
+ `views[${vi}].list`,
+ );
  }
  for (const lv of entriesOf(container.def.listViews)) {
  push(
  out,
- checkViewCompleteness(lv.def),
+ checkViewCompleteness(lv.def, boundObjectOf(lv.def, container.def)),
  `${where} › listViews.${lv.name}`,
  `views[${vi}].listViews${lv.key}`,
  );

packages/spec/api-surface/kernel.json

@@ -442,6 +442,7 @@
  "UpgradeSnapshotParsed (type)",
  "UpgradeSnapshotSchema (const)",
  "VIEW_LAYOUT_WITHOUT_BINDING (const)",
+ "VIEW_TREE_WITHOUT_PARENT_FIELD (const)",
  "ValidationError (type)",
  "ValidationErrorSchema (const)",
  "ValidationResult (type)",

packages/spec/export-origins/kernel.json

@@ -442,6 +442,7 @@
  "UpgradeSnapshotParsed": "src/kernel/package-upgrade.zod.ts#UpgradeSnapshotParsed (type)",
  "UpgradeSnapshotSchema": "src/kernel/package-upgrade.zod.ts#UpgradeSnapshotSchema (const)",
  "VIEW_LAYOUT_WITHOUT_BINDING": "src/kernel/functional-completeness.ts#VIEW_LAYOUT_WITHOUT_BINDING (const)",
+ "VIEW_TREE_WITHOUT_PARENT_FIELD": "src/kernel/functional-completeness.ts#VIEW_TREE_WITHOUT_PARENT_FIELD (const)",
  "ValidationError": "src/kernel/plugin-validator.zod.ts#ValidationError (type)",
  "ValidationErrorSchema": "src/kernel/plugin-validator.zod.ts#ValidationErrorSchema (const)",
  "ValidationResult": "src/kernel/plugin-validator.zod.ts#ValidationResult (type)",