@topogram/cli 0.3.64 → 0.3.65

package/src/validator/index.js

@@ -1,54 +1,16 @@
+import { validateCoreStatement, validateReferenceRules } from "./common.js";
+import { validateDataModelStatement, validateShapeFrom } from "./data-model.js";
+import { validateDocs } from "./docs.js";
+import { validateExpressions } from "./expressions.js";
+import { validateApiHttpProjection } from "./projections/api-http.js";
+import { validateDbProjection } from "./projections/db.js";
+import { validateProjectionGeneratorDefaults } from "./projections/generator-defaults.js";
+import { validateUiProjection } from "./projections/ui.js";
+import { buildRegistry } from "./registry.js";
 import {
-  DOC_ARRAY_FIELDS,
-  DOC_CONFIDENCE,
-  DOC_KINDS,
-  DOC_REFERENCE_FIELDS,
-  DOC_STATUSES
-} from "../workspace-docs.js";
-
-import {
-  STATEMENT_KINDS,
-  IDENTIFIER_PATTERN,
-  DOMAIN_IDENTIFIER_PATTERN,
-  DOMAIN_TAGGABLE_KINDS,
-  PITCH_IDENTIFIER_PATTERN,
-  REQUIREMENT_IDENTIFIER_PATTERN,
-  ACCEPTANCE_CRITERION_IDENTIFIER_PATTERN,
-  TASK_IDENTIFIER_PATTERN,
-  BUG_IDENTIFIER_PATTERN,
-  DOCUMENT_IDENTIFIER_PATTERN,
-  GLOBAL_STATUSES,
-  DECISION_STATUSES,
-  RULE_SEVERITIES,
-  VERIFICATION_METHODS,
-  STATUS_SETS_BY_KIND,
-  PITCH_STATUSES,
-  REQUIREMENT_STATUSES,
-  ACCEPTANCE_CRITERION_STATUSES,
-  TASK_STATUSES,
-  BUG_STATUSES,
-  PRIORITY_VALUES,
-  WORK_TYPES,
-  BUG_SEVERITIES,
-  DOC_TYPES,
-  AUDIENCES,
-  UI_SCREEN_KINDS,
-  UI_COLLECTION_PRESENTATIONS,
-  UI_NAVIGATION_PATTERNS,
-  UI_REGION_KINDS,
-  UI_PATTERN_KINDS,
-  UI_APP_SHELL_KINDS,
-  UI_WINDOWING_MODES,
-  UI_STATE_KINDS,
-  UI_DESIGN_DENSITIES,
-  UI_DESIGN_TONES,
-  UI_DESIGN_RADIUS_SCALES,
-  UI_DESIGN_COLOR_ROLES,
-  UI_DESIGN_TYPOGRAPHY_ROLES,
-  UI_DESIGN_ACTION_ROLES,
-  UI_DESIGN_ACCESSIBILITY_VALUES,
-  FIELD_SPECS
-} from "./kinds.js";
+  collectFieldMap,
+  formatLoc
+} from "./utils.js";
 import { validateWidget } from "./per-kind/widget.js";
 import { validateDomain, validateDomainTag } from "./per-kind/domain.js";
 import { validatePitch } from "./per-kind/pitch.js";
@@ -101,3499 +63,20 @@ export {
   FIELD_SPECS
 } from "./kinds.js";
 
-export function pushError(errors, message, loc) {
-  errors.push({
-    message,
-    loc
-  });
-}
-
-function renameDiagnostic(oldName, newName, example) {
-  return `${oldName} was renamed to ${newName}. Example fix: ${example}`;
-}
-
-export function formatLoc(loc) {
-  const line = loc?.start?.line ?? 1;
-  const column = loc?.start?.column ?? 1;
-  const file = loc?.file ?? "<unknown>";
-  return `${file}:${line}:${column}`;
-}
-
-export function valueAsArray(value) {
-  if (!value) {
-    return [];
-  }
-  if (value.type === "list") {
-    return value.items;
-  }
-  if (value.type === "sequence") {
-    return value.items;
-  }
-  return [value];
-}
-
-export function symbolValues(value) {
-  return valueAsArray(value).filter((item) => item.type === "symbol").map((item) => item.value);
-}
-
-export function collectFieldMap(statement) {
-  const map = new Map();
-  for (const field of statement.fields) {
-    if (!map.has(field.key)) {
-      map.set(field.key, []);
-    }
-    map.get(field.key).push(field);
-  }
-  return map;
-}
-
-export function getField(statement, key) {
-  return collectFieldMap(statement).get(key)?.[0] || null;
-}
-
-export function getFieldValue(statement, key) {
-  return getField(statement, key)?.value || null;
-}
-
-export function stringValue(value) {
-  return value?.type === "string" ? value.value : null;
-}
-
-export function symbolValue(value) {
-  return value?.type === "symbol" ? value.value : null;
-}
-
-export function blockEntries(value) {
-  return value?.type === "block" ? value.entries : [];
-}
-
-function blockSymbolItems(entry) {
-  return entry.items.filter((item) => item.type === "symbol" || item.type === "string");
-}
-
-function statementFieldNames(statement) {
-  return blockEntries(getFieldValue(statement, "fields"))
-    .map((entry) => entry.items[0])
-    .filter((item) => item?.type === "symbol")
-    .map((item) => item.value);
-}
-
-function resolveShapeBaseFieldNames(statement, registry) {
-  const explicitFieldNames = statementFieldNames(statement);
-  if (explicitFieldNames.length > 0) {
-    return explicitFieldNames;
-  }
-
-  if (!statement.from) {
-    return [];
-  }
-
-  const source = registry.get(statement.from.value);
-  if (!source || source.kind !== "entity") {
-    return [];
-  }
-
-  const sourceFieldNames = statementFieldNames(source);
-  const includeNames = symbolValues(getFieldValue(statement, "include"));
-  const excludeNames = new Set(symbolValues(getFieldValue(statement, "exclude")));
-  const selectedNames = includeNames.length > 0 ? includeNames.filter((name) => sourceFieldNames.includes(name)) : sourceFieldNames;
-
-  return selectedNames.filter((fieldName) => !excludeNames.has(fieldName));
-}
-
-function ensureSingleValueField(errors, statement, fieldMap, key, expectedTypes) {
-  const fields = fieldMap.get(key) || [];
-  if (fields.length > 1) {
-    for (const field of fields.slice(1)) {
-      pushError(errors, `Duplicate field '${key}' on ${statement.kind} ${statement.id}`, field.loc);
-    }
-  }
-
-  const field = fields[0];
-  if (!field) {
-    return;
-  }
-
-  if (!expectedTypes.includes(field.value.type)) {
-    pushError(
-      errors,
-      `Field '${key}' on ${statement.kind} ${statement.id} must be ${expectedTypes.join(" or ")}, found ${field.value.type}`,
-      field.loc
-    );
-  }
-}
-
-function validateFieldPresence(errors, statement, fieldMap) {
-  const spec = FIELD_SPECS[statement.kind];
-  if (!spec) {
-    return;
-  }
-
-  const renamedFields = new Map([
-    ["platform", ["type", "type web_surface"]],
-    ["ui_components", ["widget_bindings", "widget_bindings { screen item_list region results widget widget_data_grid }"]],
-    ["ui_design", ["design_tokens", "design_tokens { density comfortable tone operational }"]],
-    ["ui_routes", ["screen_routes", "screen_routes { screen item_list path /items }"]],
-    ["ui_screens", ["screens", "screens { item_list list title \"Items\" }"]],
-    ["ui_screen_regions", ["screen_regions", "screen_regions { screen item_list region results pattern resource_table }"]],
-    ["ui_navigation", ["navigation", "navigation { primary item_list label \"Items\" }"]],
-    ["ui_app_shell", ["app_shell", "app_shell { shell sidebar }"]],
-    ["ui_collections", ["collection_views", "collection_views { item_list presentation table }"]],
-    ["ui_actions", ["screen_actions", "screen_actions { screen item_list action create target cap_create_item }"]],
-    ["ui_visibility", ["visibility_rules", "visibility_rules { screen item_list when cap_list_items }"]],
-    ["ui_lookups", ["field_lookups", "field_lookups { field owner_id source cap_list_users }"]],
-    ["web_surface", ["web_hints", "web_hints { router file_based }"]],
-    ["ios_surface", ["ios_hints", "ios_hints { navigation stack }"]],
-    ["http", ["endpoints", "endpoints { cap_list_items method GET path /items success 200 }"]],
-    ["http_errors", ["error_responses", "error_responses { cap_list_items 404 shape_error }"]],
-    ["http_fields", ["wire_fields", "wire_fields { shape_item title title }"]],
-    ["http_responses", ["responses", "responses { cap_list_items 200 shape_item_list }"]],
-    ["http_preconditions", ["preconditions", "preconditions { cap_update_item rule_item_exists }"]],
-    ["http_idempotency", ["idempotency", "idempotency { cap_create_item key request_id }"]],
-    ["http_cache", ["cache", "cache { cap_list_items max_age 60 }"]],
-    ["http_delete", ["delete_semantics", "delete_semantics { cap_delete_item mode soft_delete }"]],
-    ["http_async", ["async_jobs", "async_jobs { cap_export_items job task_export }"]],
-    ["http_status", ["async_status", "async_status { cap_export_items path /exports/{job_id} }"]],
-    ["http_download", ["downloads", "downloads { cap_download_export content_type text/csv }"]],
-    ["http_authz", ["authorization", "authorization { cap_update_item role editor }"]],
-    ["http_callbacks", ["callbacks", "callbacks { cap_export_items event completed }"]],
-    ["db_tables", ["tables", "tables { entity_item table items }"]],
-    ["db_columns", ["columns", "columns { entity_item field title column title }"]],
-    ["db_keys", ["keys", "keys { entity_item primary [id] }"]],
-    ["db_indexes", ["indexes", "indexes { entity_item index [title] }"]],
-    ["db_relations", ["relations", "relations { entity_item foreign_key owner_id references entity_user.id }"]],
-    ["db_lifecycle", ["lifecycle", "lifecycle { entity_item timestamps created_at created_at updated_at updated_at }"]]
-  ]);
-
-  for (const key of fieldMap.keys()) {
-    if (renamedFields.has(key)) {
-      const [newName, example] = renamedFields.get(key);
-      pushError(errors, `Field '${key}' on ${statement.kind} ${statement.id} ${renameDiagnostic(`'${key}'`, `'${newName}'`, example)}`, fieldMap.get(key)[0].loc);
-      continue;
-    }
-    if (!spec.allowed.includes(key)) {
-      pushError(errors, `Field '${key}' is not allowed on ${statement.kind} ${statement.id}`, fieldMap.get(key)[0].loc);
-    }
-  }
-
-  for (const key of spec.required) {
-    if (!fieldMap.has(key)) {
-      pushError(errors, `Missing required field '${key}' on ${statement.kind} ${statement.id}`, statement.loc);
-    }
-  }
-}
-
-function validateProjectionTypeRenames(errors, statement, fieldMap) {
-  if (statement.kind !== "projection") {
-    return;
-  }
-
-  const typeField = fieldMap.get("type")?.[0];
-  const typeValue = symbolValue(typeField?.value);
-  const renamedTypes = new Map([
-    ["ui_shared", "ui_contract"],
-    ["ui_web", "web_surface"],
-    ["ui_ios", "ios_surface"],
-    ["ui_android", "android_surface"],
-    ["dotnet", "api_contract"],
-    ["api", "api_contract"],
-    ["backend", "api_contract"],
-    ["db_postgres", "db_contract"],
-    ["db_sqlite", "db_contract"]
-  ]);
-  if (!typeField || !renamedTypes.has(typeValue)) {
-    return;
-  }
-
-  const nextType = renamedTypes.get(typeValue);
-  pushError(
-    errors,
-    `Projection ${statement.id} ${renameDiagnostic(`type value '${typeValue}'`, `'${nextType}'`, `type ${nextType}`)}`,
-    typeField.value.loc
-  );
-}
-
-function validateBlockEntryLengths(errors, statement, fieldMap, key, minimumWidth) {
-  const field = fieldMap.get(key)?.[0];
-  if (!field || field.value.type !== "block") {
-    return;
-  }
-
-  for (const entry of field.value.entries) {
-    if (entry.items.length < minimumWidth) {
-      pushError(errors, `Each '${key}' entry on ${statement.kind} ${statement.id} must have at least ${minimumWidth} token(s)`, entry.loc);
-    }
-  }
-}
-
-function validateFieldShapes(errors, statement, fieldMap) {
-  ensureSingleValueField(errors, statement, fieldMap, "name", ["string"]);
-  ensureSingleValueField(errors, statement, fieldMap, "description", ["string"]);
-  ensureSingleValueField(errors, statement, fieldMap, "status", ["symbol"]);
-  ensureSingleValueField(errors, statement, fieldMap, "type", ["symbol"]);
-  ensureSingleValueField(errors, statement, fieldMap, "method", ["symbol"]);
-  ensureSingleValueField(errors, statement, fieldMap, "severity", ["symbol"]);
-  ensureSingleValueField(errors, statement, fieldMap, "category", ["symbol"]);
-  ensureSingleValueField(errors, statement, fieldMap, "version", ["string"]);
-
-  for (const key of [
-    "aliases",
-    "excludes",
-    "uses_terms",
-    "include",
-    "exclude",
-    "derived_from",
-    "applies_to",
-    "actors",
-    "roles",
-    "reads",
-    "creates",
-    "updates",
-    "deletes",
-    "input",
-    "output",
-    "context",
-    "consequences",
-    "realizes",
-    "outputs",
-    "inputs",
-    "steps",
-    "validates",
-    "scenarios",
-    "observes",
-    "metrics",
-    "alerts",
-    "source_of_truth",
-    "behavior",
-    "patterns",
-    "regions",
-    "lookups",
-    "dependencies",
-    "approvals"
-  ]) {
-    ensureSingleValueField(errors, statement, fieldMap, key, ["list"]);
-  }
-
-  for (const key of ["fields", "props", "events", "slots", "behaviors", "keys", "relations", "invariants", "rename", "overrides", "endpoints", "error_responses", "wire_fields", "responses", "preconditions", "idempotency", "cache", "delete_semantics", "async_jobs", "async_status", "downloads", "authorization", "callbacks", "screens", "collection_views", "screen_actions", "visibility_rules", "field_lookups", "screen_routes", "web_hints", "ios_hints", "app_shell", "navigation", "screen_regions", "widget_bindings", "design_tokens", "tables", "columns", "keys", "indexes", "relations", "lifecycle", "generator_defaults"]) {
-    ensureSingleValueField(errors, statement, fieldMap, key, ["block"]);
-  }
-
-  validateBlockEntryLengths(errors, statement, fieldMap, "fields", 2);
-  validateBlockEntryLengths(errors, statement, fieldMap, "props", 3);
-  validateBlockEntryLengths(errors, statement, fieldMap, "events", 2);
-  validateBlockEntryLengths(errors, statement, fieldMap, "slots", 2);
-  validateBlockEntryLengths(errors, statement, fieldMap, "invariants", 2);
-  validateBlockEntryLengths(errors, statement, fieldMap, "generator_defaults", 2);
-
-  if (statement.kind === "entity") {
-    validateBlockEntryLengths(errors, statement, fieldMap, "keys", 2);
-    validateBlockEntryLengths(errors, statement, fieldMap, "relations", 3);
-  }
-
-  if (statement.kind === "projection") {
-    validateBlockEntryLengths(errors, statement, fieldMap, "endpoints", 7);
-    validateBlockEntryLengths(errors, statement, fieldMap, "error_responses", 3);
-    validateBlockEntryLengths(errors, statement, fieldMap, "wire_fields", 5);
-    validateBlockEntryLengths(errors, statement, fieldMap, "responses", 3);
-    validateBlockEntryLengths(errors, statement, fieldMap, "preconditions", 9);
-    validateBlockEntryLengths(errors, statement, fieldMap, "idempotency", 7);
-    validateBlockEntryLengths(errors, statement, fieldMap, "cache", 11);
-    validateBlockEntryLengths(errors, statement, fieldMap, "delete_semantics", 7);
-    validateBlockEntryLengths(errors, statement, fieldMap, "async_jobs", 11);
-    validateBlockEntryLengths(errors, statement, fieldMap, "async_status", 11);
-    validateBlockEntryLengths(errors, statement, fieldMap, "downloads", 7);
-    validateBlockEntryLengths(errors, statement, fieldMap, "authorization", 3);
-    validateBlockEntryLengths(errors, statement, fieldMap, "callbacks", 11);
-    validateBlockEntryLengths(errors, statement, fieldMap, "screens", 4);
-    validateBlockEntryLengths(errors, statement, fieldMap, "collection_views", 4);
-    validateBlockEntryLengths(errors, statement, fieldMap, "screen_actions", 6);
-    validateBlockEntryLengths(errors, statement, fieldMap, "visibility_rules", 5);
-    validateBlockEntryLengths(errors, statement, fieldMap, "field_lookups", 8);
-    validateBlockEntryLengths(errors, statement, fieldMap, "screen_routes", 4);
-    validateBlockEntryLengths(errors, statement, fieldMap, "web_hints", 4);
-    validateBlockEntryLengths(errors, statement, fieldMap, "ios_hints", 4);
-    validateBlockEntryLengths(errors, statement, fieldMap, "app_shell", 2);
-    validateBlockEntryLengths(errors, statement, fieldMap, "navigation", 2);
-    validateBlockEntryLengths(errors, statement, fieldMap, "screen_regions", 4);
-    validateBlockEntryLengths(errors, statement, fieldMap, "tables", 3);
-    validateBlockEntryLengths(errors, statement, fieldMap, "columns", 5);
-    validateBlockEntryLengths(errors, statement, fieldMap, "keys", 3);
-    validateBlockEntryLengths(errors, statement, fieldMap, "indexes", 3);
-    validateBlockEntryLengths(errors, statement, fieldMap, "relations", 6);
-    validateBlockEntryLengths(errors, statement, fieldMap, "lifecycle", 3);
-  }
-}
-
-function validateStatus(errors, statement, fieldMap) {
-  const field = fieldMap.get("status")?.[0];
-  if (!field || field.value.type !== "symbol") {
-    return;
-  }
-
-  // Per-kind status table takes precedence (decision and SDLC kinds), with
-  // GLOBAL_STATUSES as the default.
-  const allowed = STATUS_SETS_BY_KIND[statement.kind] || GLOBAL_STATUSES;
-  if (!allowed.has(field.value.value)) {
-    pushError(errors, `Invalid status '${field.value.value}' on ${statement.kind} ${statement.id}`, field.loc);
-  }
-}
-
-function validateRuleSeverity(errors, statement, fieldMap) {
-  if (statement.kind !== "rule") {
-    return;
-  }
-
-  const field = fieldMap.get("severity")?.[0];
-  if (!field) {
-    return;
-  }
-
-  if (field.value.type === "symbol" && !RULE_SEVERITIES.has(field.value.value)) {
-    pushError(errors, `Invalid severity '${field.value.value}' on rule ${statement.id}`, field.loc);
-  }
-}
-
-function validateVerification(errors, statement, fieldMap) {
-  if (statement.kind !== "verification") {
-    return;
-  }
-
-  const methodField = fieldMap.get("method")?.[0];
-  if (methodField?.value.type === "symbol" && !VERIFICATION_METHODS.has(methodField.value.value)) {
-    pushError(
-      errors,
-      `Invalid verification method '${methodField.value.value}' on verification ${statement.id}`,
-      methodField.loc
-    );
-  }
-
-  const scenariosField = fieldMap.get("scenarios")?.[0];
-  if (!scenariosField || scenariosField.value.type !== "list") {
-    return;
-  }
-
-  if (scenariosField.value.items.length === 0) {
-    pushError(errors, `Verification ${statement.id} must include at least one scenario`, scenariosField.loc);
-    return;
-  }
-
-  for (const item of scenariosField.value.items) {
-    if (item.type !== "symbol" && item.type !== "string") {
-      pushError(errors, `Verification ${statement.id} scenarios must use symbols or strings`, item.loc);
-    }
-  }
-}
-
-function validateShapeFrom(errors, statement, registry) {
-  if (statement.kind !== "shape" || !statement.from) {
-    return;
-  }
-
-  const target = registry.get(statement.from.value);
-  if (!target) {
-    pushError(errors, `Shape ${statement.id} derives from missing statement '${statement.from.value}'`, statement.from.loc);
-    return;
-  }
-
-  if (target.kind !== "entity") {
-    pushError(errors, `Shape ${statement.id} can only derive from an entity, found ${target.kind} '${target.id}'`, statement.from.loc);
-  }
-}
-
-function validateReferenceKinds(errors, statement, fieldMap, registry) {
-  // Phase 2: SDLC kinds add several reference fields. The `affects` field is
-  // polymorphic — pitches/requirements/tasks/bugs all use it, so we keep the
-  // target set wide. `pitch` is single-id but lives in the same map for
-  // uniform validation.
-  const expectedByField = {
-    uses_terms: ["term"],
-    derived_from: ["entity"],
-    applies_to: ["capability"],
-    source_of_truth: ["decision"],
-    actors: ["actor"],
-    roles: ["role"],
-    reads: ["entity"],
-    creates: ["entity"],
-    updates: ["entity"],
-    deletes: ["entity"],
-    input: ["shape"],
-    output: ["shape"],
-    dependencies: [...STATEMENT_KINDS],
-    realizes: ["capability", "projection", "entity"],
-    validates: [...STATEMENT_KINDS],
-    observes: [...STATEMENT_KINDS],
-    inputs: [...STATEMENT_KINDS],
-    outputs: null,
-    steps: null,
-    scenarios: null,
-    metrics: null,
-    alerts: null,
-    aliases: null,
-    excludes: null,
-    include: null,
-    exclude: null,
-    context: null,
-    consequences: null,
-    pitch: ["pitch"],
-    requirement: null,
-    from_requirement: ["requirement"],
-    affects: ["capability", "entity", "rule", "projection", "widget", "orchestration", "operation"],
-    introduces_rules: ["rule"],
-    respects_rules: ["rule"],
-    decisions: ["decision"],
-    introduces_decisions: ["decision"],
-    satisfies: ["requirement", "acceptance_criterion"],
-    acceptance_refs: ["acceptance_criterion"],
-    requirement_refs: ["requirement"],
-    fixes_bugs: ["bug"],
-    blocks: ["task"],
-    blocked_by: ["task"],
-    claimed_by: ["actor", "role"],
-    violates: ["rule"],
-    surfaces_rule: ["rule"],
-    introduced_in: ["task", "bug"],
-    fixed_in: ["task"],
-    fixed_in_verification: ["verification"],
-    supersedes: null,
-    modifies: [...STATEMENT_KINDS],
-    introduces: [...STATEMENT_KINDS],
-    removes: [...STATEMENT_KINDS]
-  };
-
-  for (const [key, allowedKinds] of Object.entries(expectedByField)) {
-    const field = fieldMap.get(key)?.[0];
-    if (!field || !allowedKinds) {
-      continue;
-    }
-
-    for (const item of valueAsArray(field.value)) {
-      if (item.type !== "symbol") {
-        pushError(errors, `Field '${key}' on ${statement.kind} ${statement.id} must only contain symbols`, item.loc);
-        continue;
-      }
-
-      const target = registry.get(item.value);
-      if (!target) {
-        pushError(errors, `Missing reference '${item.value}' in field '${key}' on ${statement.kind} ${statement.id}`, item.loc);
-        continue;
-      }
-
-      if (!allowedKinds.includes(target.kind)) {
-        pushError(
-          errors,
-          `Field '${key}' on ${statement.kind} ${statement.id} must reference ${allowedKinds.join(" or ")}, found ${target.kind} '${target.id}'`,
-          item.loc
-        );
-      }
-    }
-  }
-}
-
-function validateEntityRelations(errors, statement, fieldMap, registry) {
-  if (statement.kind !== "entity") {
-    return;
-  }
-
-  const field = fieldMap.get("relations")?.[0];
-  if (!field || field.value.type !== "block") {
-    return;
-  }
-
-  for (const entry of field.value.entries) {
-    const [left, operator, target] = entry.items;
-    if (!left || !operator || !target) {
-      continue;
-    }
-
-    if (left.type !== "symbol" || operator.type !== "symbol" || target.type !== "symbol") {
-      pushError(errors, `Relation entries on entity ${statement.id} must use symbols`, entry.loc);
-      continue;
-    }
-
-    if (operator.value !== "references") {
-      pushError(errors, `Relation entries on entity ${statement.id} must use 'references'`, operator.loc);
-    }
-
-    const [entityId] = target.value.split(".");
-    const related = registry.get(entityId);
-    if (!related) {
-      pushError(errors, `Relation on entity ${statement.id} references missing entity '${entityId}'`, target.loc);
-      continue;
-    }
-
-    if (related.kind !== "entity") {
-      pushError(errors, `Relation on entity ${statement.id} must target an entity, found ${related.kind} '${related.id}'`, target.loc);
-    }
-  }
-}
-
-function isIdentifierLike(token) {
-  return typeof token === "string" && token.length > 0;
-}
-
-function isComparator(token) {
-  return ["==", "!=", "<", "<=", ">", ">="].includes(token);
-}
-
-function validateInvariantEntry(errors, statement, entry) {
-  const tokens = blockSymbolItems(entry).map((item) => item.value);
-  if (tokens.length < 2) {
-    pushError(errors, `Invariant on ${statement.kind} ${statement.id} is too short`, entry.loc);
-    return;
-  }
-
-  const [left, op, ...rest] = tokens;
-  if (!isIdentifierLike(left)) {
-    pushError(errors, `Invariant on ${statement.kind} ${statement.id} must start with a field or expression target`, entry.loc);
-    return;
-  }
-
-  if (op === "requires") {
-    if (rest.length < 3) {
-      pushError(errors, `Invariant '${tokens.join(" ")}' on ${statement.kind} ${statement.id} must be '<field> requires <field> <op> <value>'`, entry.loc);
-    } else if (!isComparator(rest[1])) {
-      pushError(errors, `Invariant '${tokens.join(" ")}' on ${statement.kind} ${statement.id} uses an invalid comparator '${rest[1]}'`, entry.loc);
-    }
-    return;
-  }
-
-  if (op === "length") {
-    if (rest.length !== 2 || !["<", "<=", ">", ">=", "=="].includes(rest[0])) {
-      pushError(errors, `Invariant '${tokens.join(" ")}' on ${statement.kind} ${statement.id} must be '<field> length <op> <number>'`, entry.loc);
-    }
-    return;
-  }
-
-  if (op === "format") {
-    if (rest.length !== 2 || rest[0] !== "==") {
-      pushError(errors, `Invariant '${tokens.join(" ")}' on ${statement.kind} ${statement.id} must be '<field> format == <format>'`, entry.loc);
-    }
-    return;
-  }
-
-  if (isComparator(op)) {
-    if (rest.length < 1) {
-      pushError(errors, `Invariant '${tokens.join(" ")}' on ${statement.kind} ${statement.id} is missing a right-hand value`, entry.loc);
-      return;
-    }
-
-    if (rest[1] === "implies") {
-      const [, , impliedField, impliedOperator, impliedValue] = rest;
-      if (!impliedField || !impliedOperator || !impliedValue) {
-        pushError(errors, `Invariant '${tokens.join(" ")}' on ${statement.kind} ${statement.id} must fully specify the implied clause`, entry.loc);
-      } else if (!(impliedOperator === "is" || isComparator(impliedOperator))) {
-        pushError(errors, `Invariant '${tokens.join(" ")}' on ${statement.kind} ${statement.id} has invalid implied operator '${impliedOperator}'`, entry.loc);
-      }
-      return;
-    }
-
-    return;
-  }
-
-  pushError(errors, `Invariant '${tokens.join(" ")}' on ${statement.kind} ${statement.id} uses unsupported form`, entry.loc);
-}
-
-function validateRuleExpressionValue(errors, statement, field, label) {
-  if (!field) {
-    return;
-  }
-
-  const items = valueAsArray(field.value);
-  if (items.length !== 1) {
-    pushError(errors, `Field '${label}' on rule ${statement.id} must contain a single expression`, field.loc);
-    return;
-  }
-
-  const item = items[0];
-  if (item.type !== "string" && item.type !== "symbol") {
-    pushError(errors, `Field '${label}' on rule ${statement.id} must be a string or symbol expression`, field.loc);
-    return;
-  }
-
-  const text = item.value.trim();
-  if (text.length === 0) {
-    pushError(errors, `Field '${label}' on rule ${statement.id} must not be empty`, field.loc);
-    return;
-  }
-
-  if (label === "requirement" || label === "condition") {
-    if (!/(==|!=|<=|>=|<|>)/.test(text)) {
-      pushError(errors, `Field '${label}' on rule ${statement.id} must include a comparison operator`, field.loc);
-    }
-  }
-}
-
-function validateExpressions(errors, statement, fieldMap) {
-  if (statement.kind === "entity") {
-    const invariantsField = fieldMap.get("invariants")?.[0];
-    if (invariantsField?.value.type === "block") {
-      for (const entry of invariantsField.value.entries) {
-        validateInvariantEntry(errors, statement, entry);
-      }
-    }
-  }
-
-  if (statement.kind === "rule") {
-    validateRuleExpressionValue(errors, statement, fieldMap.get("condition")?.[0], "condition");
-    validateRuleExpressionValue(errors, statement, fieldMap.get("requirement")?.[0], "requirement");
-  }
-}
-
-function validateShapeTransforms(errors, statement, fieldMap, registry) {
-  if (statement.kind !== "shape") {
-    return;
-  }
-
-  const baseFieldNames = resolveShapeBaseFieldNames(statement, registry);
-  const baseFieldSet = new Set(baseFieldNames);
-  const source = statement.from ? registry.get(statement.from.value) : null;
-  const sourceFieldSet = new Set(source ? statementFieldNames(source) : []);
-  const includeField = fieldMap.get("include")?.[0];
-  const excludeField = fieldMap.get("exclude")?.[0];
-
-  for (const [fieldKey, field] of [
-    ["include", includeField],
-    ["exclude", excludeField]
-  ]) {
-    if (!field) {
-      continue;
-    }
-
-    for (const item of valueAsArray(field.value)) {
-      if (item.type !== "symbol") {
-        continue;
-      }
-
-      if (statement.from && !sourceFieldSet.has(item.value) && fieldKey === "include") {
-        pushError(errors, `Shape ${statement.id} includes unknown field '${item.value}' from ${statement.from.value}`, item.loc);
-      }
-
-      if (statement.from && fieldKey === "exclude") {
-        if (!sourceFieldSet.has(item.value)) {
-          pushError(errors, `Shape ${statement.id} excludes unknown field '${item.value}' from ${statement.from.value}`, item.loc);
-        }
-      }
-    }
-  }
-
-  const renameEntries = blockEntries(getFieldValue(statement, "rename"));
-  const renameFrom = new Map();
-  const renameTo = new Map();
-
-  for (const entry of renameEntries) {
-    const items = blockSymbolItems(entry);
-    if (items.length !== 2) {
-      pushError(errors, `Each 'rename' entry on shape ${statement.id} must be exactly '<from> <to>'`, entry.loc);
-      continue;
-    }
-
-    const [fromItem, toItem] = items;
-    if (!baseFieldSet.has(fromItem.value)) {
-      pushError(errors, `Shape ${statement.id} renames unknown field '${fromItem.value}'`, fromItem.loc);
-    }
-
-    if (renameFrom.has(fromItem.value)) {
-      pushError(errors, `Shape ${statement.id} renames field '${fromItem.value}' more than once`, fromItem.loc);
-    } else {
-      renameFrom.set(fromItem.value, toItem.value);
-    }
-
-    if (renameTo.has(toItem.value)) {
-      pushError(errors, `Shape ${statement.id} renames multiple fields to '${toItem.value}'`, toItem.loc);
-    } else {
-      renameTo.set(toItem.value, fromItem.value);
-    }
-  }
-
-  const finalFieldNames = baseFieldNames.map((fieldName) => renameFrom.get(fieldName) || fieldName);
-  const finalFieldSet = new Set();
-  for (const fieldName of finalFieldNames) {
-    if (finalFieldSet.has(fieldName)) {
-      pushError(errors, `Shape ${statement.id} produces duplicate projected field '${fieldName}'`, statement.loc);
-      continue;
-    }
-    finalFieldSet.add(fieldName);
-  }
-
-  const sourceNameSet = new Set(baseFieldNames);
-  const overrideEntries = blockEntries(getFieldValue(statement, "overrides"));
-  const seenOverrides = new Set();
-
-  for (const entry of overrideEntries) {
-    const items = blockSymbolItems(entry);
-    if (items.length < 2) {
-      pushError(errors, `Each 'overrides' entry on shape ${statement.id} must include a field and at least one override`, entry.loc);
-      continue;
-    }
-
-    const [fieldItem, ...rest] = items;
-    if (!finalFieldSet.has(fieldItem.value) && !sourceNameSet.has(fieldItem.value)) {
-      pushError(errors, `Shape ${statement.id} overrides unknown field '${fieldItem.value}'`, fieldItem.loc);
-    }
-
-    if (seenOverrides.has(fieldItem.value)) {
-      pushError(errors, `Shape ${statement.id} overrides field '${fieldItem.value}' more than once`, fieldItem.loc);
-    } else {
-      seenOverrides.add(fieldItem.value);
-    }
-
-    let sawChange = false;
-    for (let i = 0; i < rest.length; i += 1) {
-      const token = rest[i];
-      if (token.value === "required" || token.value === "optional") {
-        sawChange = true;
-        continue;
-      }
-
-      if (token.value === "type") {
-        sawChange = true;
-        if (!rest[i + 1]) {
-          pushError(errors, `Shape ${statement.id} override for '${fieldItem.value}' is missing a type value`, token.loc);
-        } else {
-          i += 1;
-        }
-        continue;
-      }
-
-      if (token.value === "default") {
-        sawChange = true;
-        if (!rest[i + 1]) {
-          pushError(errors, `Shape ${statement.id} override for '${fieldItem.value}' is missing a default value`, token.loc);
-        } else {
-          i += 1;
-        }
-        continue;
-      }
-
-      pushError(errors, `Shape ${statement.id} override for '${fieldItem.value}' has unknown directive '${token.value}'`, token.loc);
-    }
-
-    if (!sawChange) {
-      pushError(errors, `Shape ${statement.id} override for '${fieldItem.value}' must specify at least one valid directive`, entry.loc);
-    }
-  }
-}
-
-function validateProjectionHttp(errors, statement, fieldMap, registry) {
-  if (statement.kind !== "projection") {
-    return;
-  }
-
-  const httpField = fieldMap.get("endpoints")?.[0];
-  if (!httpField || httpField.value.type !== "block") {
-    return;
-  }
-
-  const realized = new Set(symbolValues(getFieldValue(statement, "realizes")));
-
-  for (const entry of httpField.value.entries) {
-    const tokens = blockSymbolItems(entry).map((item) => item.value);
-    const capabilityId = tokens[0];
-    if (!capabilityId) {
-      continue;
-    }
-
-    const target = registry.get(capabilityId);
-    if (!target) {
-      pushError(errors, `Projection ${statement.id} http metadata references missing capability '${capabilityId}'`, entry.loc);
-      continue;
-    }
-    if (target.kind !== "capability") {
-      pushError(errors, `Projection ${statement.id} http metadata must target a capability, found ${target.kind} '${target.id}'`, entry.loc);
-    }
-    if (!realized.has(capabilityId)) {
-      pushError(errors, `Projection ${statement.id} http metadata for '${capabilityId}' must also appear in 'realizes'`, entry.loc);
-    }
-
-    const directives = new Map();
-    for (let i = 1; i < tokens.length; i += 2) {
-      const key = tokens[i];
-      const value = tokens[i + 1];
-      if (!value) {
-        pushError(errors, `Projection ${statement.id} http metadata for '${capabilityId}' is missing a value for '${key}'`, entry.loc);
-        continue;
-      }
-      directives.set(key, value);
-    }
-
-    for (const requiredKey of ["method", "path", "success"]) {
-      if (!directives.has(requiredKey)) {
-        pushError(errors, `Projection ${statement.id} http metadata for '${capabilityId}' must include '${requiredKey}'`, entry.loc);
-      }
-    }
-
-    for (const key of directives.keys()) {
-      if (!["method", "path", "success", "auth", "request"].includes(key)) {
-        pushError(errors, `Projection ${statement.id} http metadata for '${capabilityId}' has unknown directive '${key}'`, entry.loc);
-      }
-    }
-
-    const method = directives.get("method");
-    if (method && !["GET", "POST", "PUT", "PATCH", "DELETE"].includes(method)) {
-      pushError(errors, `Projection ${statement.id} http metadata for '${capabilityId}' has invalid method '${method}'`, entry.loc);
-    }
-
-    const path = directives.get("path");
-    if (path && !path.startsWith("/")) {
-      pushError(errors, `Projection ${statement.id} http metadata for '${capabilityId}' must use an absolute path`, entry.loc);
-    }
-
-    const success = directives.get("success");
-    if (success && !/^\d{3}$/.test(success)) {
-      pushError(errors, `Projection ${statement.id} http metadata for '${capabilityId}' must use a 3-digit success status`, entry.loc);
-    }
-
-    const auth = directives.get("auth");
-    if (auth && !["none", "user", "manager", "admin"].includes(auth)) {
-      pushError(errors, `Projection ${statement.id} http metadata for '${capabilityId}' has invalid auth mode '${auth}'`, entry.loc);
-    }
-
-    const request = directives.get("request");
-    if (request && !["body", "query", "path", "none"].includes(request)) {
-      pushError(errors, `Projection ${statement.id} http metadata for '${capabilityId}' has invalid request placement '${request}'`, entry.loc);
-    }
-  }
-}
-
-function validateProjectionHttpErrors(errors, statement, fieldMap, registry) {
-  if (statement.kind !== "projection") {
-    return;
-  }
-
-  const httpErrorsField = fieldMap.get("error_responses")?.[0];
-  if (!httpErrorsField || httpErrorsField.value.type !== "block") {
-    return;
-  }
-
-  const realized = new Set(symbolValues(getFieldValue(statement, "realizes")));
-  for (const entry of httpErrorsField.value.entries) {
-    const tokens = blockSymbolItems(entry).map((item) => item.value);
-    const [capabilityId, errorCode, status] = tokens;
-
-    const target = registry.get(capabilityId);
-    if (!target) {
-      pushError(errors, `Projection ${statement.id} error_responses references missing capability '${capabilityId}'`, entry.loc);
-      continue;
-    }
-    if (target.kind !== "capability") {
-      pushError(errors, `Projection ${statement.id} error_responses must target a capability, found ${target.kind} '${target.id}'`, entry.loc);
-    }
-    if (!realized.has(capabilityId)) {
-      pushError(errors, `Projection ${statement.id} error_responses for '${capabilityId}' must also appear in 'realizes'`, entry.loc);
-    }
-    if (!/^\d{3}$/.test(status || "")) {
-      pushError(errors, `Projection ${statement.id} error_responses for '${capabilityId}' must use a 3-digit status`, entry.loc);
-    }
-    if (!errorCode) {
-      pushError(errors, `Projection ${statement.id} error_responses for '${capabilityId}' must include an error code`, entry.loc);
-    }
-  }
-}
-
-function resolveCapabilityContractFields(registry, capabilityId, direction) {
-  const capability = registry.get(capabilityId);
-  if (!capability || capability.kind !== "capability") {
-    return new Set();
-  }
-
-  const refsField = direction === "input" ? getFieldValue(capability, "input") : getFieldValue(capability, "output");
-  const shapeId = symbolValues(refsField)[0];
-  if (!shapeId) {
-    return new Set();
-  }
-
-  const shape = registry.get(shapeId);
-  if (!shape || shape.kind !== "shape") {
-    return new Set();
-  }
-
-  const explicitFields = statementFieldNames(shape);
-  if (explicitFields.length > 0) {
-    return new Set(explicitFields);
-  }
-
-  return new Set(resolveShapeBaseFieldNames(shape, registry));
-}
-
-function validateProjectionHttpFields(errors, statement, fieldMap, registry) {
-  if (statement.kind !== "projection") {
-    return;
-  }
-
-  const httpFieldsField = fieldMap.get("wire_fields")?.[0];
-  if (!httpFieldsField || httpFieldsField.value.type !== "block") {
-    return;
-  }
-
-  const realized = new Set(symbolValues(getFieldValue(statement, "realizes")));
-  for (const entry of httpFieldsField.value.entries) {
-    const tokens = blockSymbolItems(entry).map((item) => item.value);
-    const [capabilityId, direction, fieldName, keywordIn, location, maybeAs, maybeWireName] = tokens;
-
-    const capability = registry.get(capabilityId);
-    if (!capability) {
-      pushError(errors, `Projection ${statement.id} wire_fields references missing capability '${capabilityId}'`, entry.loc);
-      continue;
-    }
-    if (capability.kind !== "capability") {
-      pushError(errors, `Projection ${statement.id} wire_fields must target a capability, found ${capability.kind} '${capability.id}'`, entry.loc);
-    }
-    if (!realized.has(capabilityId)) {
-      pushError(errors, `Projection ${statement.id} wire_fields for '${capabilityId}' must also appear in 'realizes'`, entry.loc);
-    }
-    if (!["input", "output"].includes(direction)) {
-      pushError(errors, `Projection ${statement.id} wire_fields for '${capabilityId}' has invalid direction '${direction}'`, entry.loc);
-    }
-    if (keywordIn !== "in") {
-      pushError(errors, `Projection ${statement.id} wire_fields for '${capabilityId}' must use 'in' before the location`, entry.loc);
-    }
-    if (!["path", "query", "header", "body"].includes(location)) {
-      pushError(errors, `Projection ${statement.id} wire_fields for '${capabilityId}' has invalid location '${location}'`, entry.loc);
-    }
-    if (maybeAs && maybeAs !== "as") {
-      pushError(errors, `Projection ${statement.id} wire_fields for '${capabilityId}' has unexpected token '${maybeAs}'`, entry.loc);
-    }
-    if (maybeAs === "as" && !maybeWireName) {
-      pushError(errors, `Projection ${statement.id} wire_fields for '${capabilityId}' must provide a wire name after 'as'`, entry.loc);
-    }
-
-    const availableFields = resolveCapabilityContractFields(registry, capabilityId, direction);
-    if (fieldName && availableFields.size > 0 && !availableFields.has(fieldName)) {
-      pushError(errors, `Projection ${statement.id} wire_fields references unknown ${direction} field '${fieldName}' on ${capabilityId}`, entry.loc);
-    }
-  }
-}
-
-function validateProjectionHttpResponses(errors, statement, fieldMap, registry) {
-  if (statement.kind !== "projection") {
-    return;
-  }
-
-  const httpResponsesField = fieldMap.get("responses")?.[0];
-  if (!httpResponsesField || httpResponsesField.value.type !== "block") {
-    return;
-  }
-
-  const realized = new Set(symbolValues(getFieldValue(statement, "realizes")));
-  for (const entry of httpResponsesField.value.entries) {
-    const tokens = blockSymbolItems(entry).map((item) => item.value);
-    const capabilityId = tokens[0];
-    const capability = registry.get(capabilityId);
-
-    if (!capability) {
-      pushError(errors, `Projection ${statement.id} responses references missing capability '${capabilityId}'`, entry.loc);
-      continue;
-    }
-    if (capability.kind !== "capability") {
-      pushError(errors, `Projection ${statement.id} responses must target a capability, found ${capability.kind} '${capability.id}'`, entry.loc);
-    }
-    if (!realized.has(capabilityId)) {
-      pushError(errors, `Projection ${statement.id} responses for '${capabilityId}' must also appear in 'realizes'`, entry.loc);
-    }
-
-    const directives = parseProjectionHttpResponsesDirectives(tokens.slice(1));
-    for (const message of directives.errors) {
-      pushError(errors, `Projection ${statement.id} responses for '${capabilityId}' ${message}`, entry.loc);
-    }
-
-    if (!directives.mode) {
-      pushError(errors, `Projection ${statement.id} responses for '${capabilityId}' must include 'mode'`, entry.loc);
-    }
-
-    const mode = directives.mode;
-    if (mode && !["item", "collection", "paged", "cursor"].includes(mode)) {
-      pushError(errors, `Projection ${statement.id} responses for '${capabilityId}' has invalid mode '${mode}'`, entry.loc);
-    }
-
-    const itemShapeId = directives.item;
-    if (mode && mode !== "item" && !itemShapeId) {
-      pushError(errors, `Projection ${statement.id} responses for '${capabilityId}' must include 'item' for mode '${mode}'`, entry.loc);
-    }
-    if (itemShapeId) {
-      const itemShape = registry.get(itemShapeId);
-      if (!itemShape) {
-        pushError(errors, `Projection ${statement.id} responses for '${capabilityId}' references missing shape '${itemShapeId}'`, entry.loc);
-      } else if (itemShape.kind !== "shape") {
-        pushError(errors, `Projection ${statement.id} responses for '${capabilityId}' must reference a shape for 'item', found ${itemShape.kind} '${itemShape.id}'`, entry.loc);
-      }
-    }
-
-    if (mode === "cursor") {
-      if (!directives.cursor?.requestAfter) {
-        pushError(errors, `Projection ${statement.id} responses for '${capabilityId}' must include 'cursor request_after <field>'`, entry.loc);
-      }
-      if (!directives.cursor?.responseNext) {
-        pushError(errors, `Projection ${statement.id} responses for '${capabilityId}' must include 'cursor response_next <wire_name>'`, entry.loc);
-      }
-      if (!directives.limit) {
-        pushError(errors, `Projection ${statement.id} responses for '${capabilityId}' must include 'limit field <field> default <n> max <n>'`, entry.loc);
-      }
-      if (!directives.sort) {
-        pushError(errors, `Projection ${statement.id} responses for '${capabilityId}' must include 'sort by <field> direction <asc|desc>'`, entry.loc);
-      }
-    }
-
-    if (directives.sort && !["asc", "desc"].includes(directives.sort.direction || "")) {
-      pushError(errors, `Projection ${statement.id} responses for '${capabilityId}' has invalid sort direction '${directives.sort.direction}'`, entry.loc);
-    }
-
-    if (directives.total && !["true", "false"].includes(directives.total.included || "")) {
-      pushError(errors, `Projection ${statement.id} responses for '${capabilityId}' has invalid total included value '${directives.total.included}'`, entry.loc);
-    }
-
-    if (directives.limit) {
-      const defaultValue = Number.parseInt(directives.limit.defaultValue || "", 10);
-      const maxValue = Number.parseInt(directives.limit.maxValue || "", 10);
-      if (!Number.isInteger(defaultValue) || !Number.isInteger(maxValue)) {
-        pushError(errors, `Projection ${statement.id} responses for '${capabilityId}' must use integer default/max values for 'limit'`, entry.loc);
-      } else if (defaultValue > maxValue) {
-        pushError(errors, `Projection ${statement.id} responses for '${capabilityId}' must use default <= max for 'limit'`, entry.loc);
-      }
-    }
-
-    const inputFields = resolveCapabilityContractFields(registry, capabilityId, "input");
-    const outputFields = resolveCapabilityContractFields(registry, capabilityId, "output");
-    if (directives.cursor?.requestAfter && inputFields.size > 0 && !inputFields.has(directives.cursor.requestAfter)) {
-      pushError(errors, `Projection ${statement.id} responses references unknown input field '${directives.cursor.requestAfter}' for cursor request_after on ${capabilityId}`, entry.loc);
-    }
-    if (directives.limit?.field && inputFields.size > 0 && !inputFields.has(directives.limit.field)) {
-      pushError(errors, `Projection ${statement.id} responses references unknown input field '${directives.limit.field}' for limit on ${capabilityId}`, entry.loc);
-    }
-    if (directives.sort?.field && outputFields.size > 0 && !outputFields.has(directives.sort.field)) {
-      pushError(errors, `Projection ${statement.id} responses references unknown output field '${directives.sort.field}' for sort on ${capabilityId}`, entry.loc);
-    }
-  }
-}
-
-function validateProjectionHttpPreconditions(errors, statement, fieldMap, registry) {
-  if (statement.kind !== "projection") {
-    return;
-  }
-
-  const httpPreconditionsField = fieldMap.get("preconditions")?.[0];
-  if (!httpPreconditionsField || httpPreconditionsField.value.type !== "block") {
-    return;
-  }
-
-  const realized = new Set(symbolValues(getFieldValue(statement, "realizes")));
-  for (const entry of httpPreconditionsField.value.entries) {
-    const tokens = blockSymbolItems(entry).map((item) => item.value);
-    const [capabilityId] = tokens;
-    const capability = registry.get(capabilityId);
-
-    if (!capability) {
-      pushError(errors, `Projection ${statement.id} preconditions references missing capability '${capabilityId}'`, entry.loc);
-      continue;
-    }
-    if (capability.kind !== "capability") {
-      pushError(errors, `Projection ${statement.id} preconditions must target a capability, found ${capability.kind} '${capability.id}'`, entry.loc);
-    }
-    if (!realized.has(capabilityId)) {
-      pushError(errors, `Projection ${statement.id} preconditions for '${capabilityId}' must also appear in 'realizes'`, entry.loc);
-    }
-
-    const directives = new Map();
-    for (let i = 1; i < tokens.length; i += 2) {
-      const key = tokens[i];
-      const value = tokens[i + 1];
-      if (!value) {
-        pushError(errors, `Projection ${statement.id} preconditions for '${capabilityId}' is missing a value for '${key}'`, entry.loc);
-        continue;
-      }
-      directives.set(key, value);
-    }
-
-    for (const requiredKey of ["header", "required", "error", "source", "code"]) {
-      if (!directives.has(requiredKey)) {
-        pushError(errors, `Projection ${statement.id} preconditions for '${capabilityId}' must include '${requiredKey}'`, entry.loc);
-      }
-    }
-
-    for (const key of directives.keys()) {
-      if (!["header", "required", "error", "source", "code"].includes(key)) {
-        pushError(errors, `Projection ${statement.id} preconditions for '${capabilityId}' has unknown directive '${key}'`, entry.loc);
-      }
-    }
-
-    const required = directives.get("required");
-    if (required && !["true", "false"].includes(required)) {
-      pushError(errors, `Projection ${statement.id} preconditions for '${capabilityId}' has invalid required value '${required}'`, entry.loc);
-    }
-
-    const errorStatus = directives.get("error");
-    if (errorStatus && !/^\d{3}$/.test(errorStatus)) {
-      pushError(errors, `Projection ${statement.id} preconditions for '${capabilityId}' must use a 3-digit error status`, entry.loc);
-    }
-
-    const sourceField = directives.get("source");
-    const outputFields = resolveCapabilityContractFields(registry, capabilityId, "output");
-    if (sourceField && outputFields.size > 0 && !outputFields.has(sourceField)) {
-      pushError(errors, `Projection ${statement.id} preconditions references unknown output field '${sourceField}' on ${capabilityId}`, entry.loc);
-    }
-  }
-}
-
-function validateProjectionHttpIdempotency(errors, statement, fieldMap, registry) {
-  if (statement.kind !== "projection") {
-    return;
-  }
-
-  const httpIdempotencyField = fieldMap.get("idempotency")?.[0];
-  if (!httpIdempotencyField || httpIdempotencyField.value.type !== "block") {
-    return;
-  }
-
-  const realized = new Set(symbolValues(getFieldValue(statement, "realizes")));
-  for (const entry of httpIdempotencyField.value.entries) {
-    const tokens = blockSymbolItems(entry).map((item) => item.value);
-    const [capabilityId] = tokens;
-    const capability = registry.get(capabilityId);
-
-    if (!capability) {
-      pushError(errors, `Projection ${statement.id} idempotency references missing capability '${capabilityId}'`, entry.loc);
-      continue;
-    }
-    if (capability.kind !== "capability") {
-      pushError(errors, `Projection ${statement.id} idempotency must target a capability, found ${capability.kind} '${capability.id}'`, entry.loc);
-    }
-    if (!realized.has(capabilityId)) {
-      pushError(errors, `Projection ${statement.id} idempotency for '${capabilityId}' must also appear in 'realizes'`, entry.loc);
-    }
-
-    const directives = new Map();
-    for (let i = 1; i < tokens.length; i += 2) {
-      const key = tokens[i];
-      const value = tokens[i + 1];
-      if (!value) {
-        pushError(errors, `Projection ${statement.id} idempotency for '${capabilityId}' is missing a value for '${key}'`, entry.loc);
-        continue;
-      }
-      directives.set(key, value);
-    }
-
-    for (const requiredKey of ["header", "required", "error", "code"]) {
-      if (!directives.has(requiredKey)) {
-        pushError(errors, `Projection ${statement.id} idempotency for '${capabilityId}' must include '${requiredKey}'`, entry.loc);
-      }
-    }
-
-    for (const key of directives.keys()) {
-      if (!["header", "required", "error", "code"].includes(key)) {
-        pushError(errors, `Projection ${statement.id} idempotency for '${capabilityId}' has unknown directive '${key}'`, entry.loc);
-      }
-    }
-
-    const required = directives.get("required");
-    if (required && !["true", "false"].includes(required)) {
-      pushError(errors, `Projection ${statement.id} idempotency for '${capabilityId}' has invalid required value '${required}'`, entry.loc);
-    }
-
-    const errorStatus = directives.get("error");
-    if (errorStatus && !/^\d{3}$/.test(errorStatus)) {
-      pushError(errors, `Projection ${statement.id} idempotency for '${capabilityId}' must use a 3-digit error status`, entry.loc);
-    }
-  }
-}
-
-function validateProjectionHttpCache(errors, statement, fieldMap, registry) {
-  if (statement.kind !== "projection") {
-    return;
-  }
-
-  const httpCacheField = fieldMap.get("cache")?.[0];
-  if (!httpCacheField || httpCacheField.value.type !== "block") {
-    return;
-  }
-
-  const realized = new Set(symbolValues(getFieldValue(statement, "realizes")));
-  const httpEntries = blockEntries(getFieldValue(statement, "endpoints"));
-  const httpMethodsByCapability = new Map();
-
-  for (const entry of httpEntries) {
-    const tokens = blockSymbolItems(entry).map((item) => item.value);
-    const capabilityId = tokens[0];
-    for (let i = 1; i < tokens.length - 1; i += 1) {
-      if (tokens[i] === "method") {
-        httpMethodsByCapability.set(capabilityId, tokens[i + 1]);
-        break;
-      }
-    }
-  }
-
-  for (const entry of httpCacheField.value.entries) {
-    const tokens = blockSymbolItems(entry).map((item) => item.value);
-    const [capabilityId] = tokens;
-    const capability = registry.get(capabilityId);
-
-    if (!capability) {
-      pushError(errors, `Projection ${statement.id} cache references missing capability '${capabilityId}'`, entry.loc);
-      continue;
-    }
-    if (capability.kind !== "capability") {
-      pushError(errors, `Projection ${statement.id} cache must target a capability, found ${capability.kind} '${capability.id}'`, entry.loc);
-    }
-    if (!realized.has(capabilityId)) {
-      pushError(errors, `Projection ${statement.id} cache for '${capabilityId}' must also appear in 'realizes'`, entry.loc);
-    }
-
-    const directives = new Map();
-    for (let i = 1; i < tokens.length; i += 2) {
-      const key = tokens[i];
-      const value = tokens[i + 1];
-      if (!value) {
-        pushError(errors, `Projection ${statement.id} cache for '${capabilityId}' is missing a value for '${key}'`, entry.loc);
-        continue;
-      }
-      directives.set(key, value);
-    }
-
-    for (const requiredKey of ["response_header", "request_header", "required", "not_modified", "source", "code"]) {
-      if (!directives.has(requiredKey)) {
-        pushError(errors, `Projection ${statement.id} cache for '${capabilityId}' must include '${requiredKey}'`, entry.loc);
-      }
-    }
-
-    for (const key of directives.keys()) {
-      if (!["response_header", "request_header", "required", "not_modified", "source", "code"].includes(key)) {
-        pushError(errors, `Projection ${statement.id} cache for '${capabilityId}' has unknown directive '${key}'`, entry.loc);
-      }
-    }
-
-    const required = directives.get("required");
-    if (required && !["true", "false"].includes(required)) {
-      pushError(errors, `Projection ${statement.id} cache for '${capabilityId}' has invalid required value '${required}'`, entry.loc);
-    }
-
-    const notModifiedStatus = directives.get("not_modified");
-    if (notModifiedStatus && notModifiedStatus !== "304") {
-      pushError(errors, `Projection ${statement.id} cache for '${capabilityId}' must use 304 for 'not_modified'`, entry.loc);
-    }
-
-    const sourceField = directives.get("source");
-    const outputFields = resolveCapabilityContractFields(registry, capabilityId, "output");
-    if (sourceField && outputFields.size > 0 && !outputFields.has(sourceField)) {
-      pushError(errors, `Projection ${statement.id} cache references unknown output field '${sourceField}' on ${capabilityId}`, entry.loc);
-    }
-
-    const method = httpMethodsByCapability.get(capabilityId);
-    if (method && method !== "GET") {
-      pushError(errors, `Projection ${statement.id} cache for '${capabilityId}' requires an HTTP GET realization, found '${method}'`, entry.loc);
-    }
-  }
-}
-
-function validateProjectionHttpDelete(errors, statement, fieldMap, registry) {
-  if (statement.kind !== "projection") {
-    return;
-  }
-
-  const httpDeleteField = fieldMap.get("delete_semantics")?.[0];
-  if (!httpDeleteField || httpDeleteField.value.type !== "block") {
-    return;
-  }
-
-  const realized = new Set(symbolValues(getFieldValue(statement, "realizes")));
-  for (const entry of httpDeleteField.value.entries) {
-    const tokens = blockSymbolItems(entry).map((item) => item.value);
-    const [capabilityId] = tokens;
-    const capability = registry.get(capabilityId);
-
-    if (!capability) {
-      pushError(errors, `Projection ${statement.id} delete_semantics references missing capability '${capabilityId}'`, entry.loc);
-      continue;
-    }
-    if (capability.kind !== "capability") {
-      pushError(errors, `Projection ${statement.id} delete_semantics must target a capability, found ${capability.kind} '${capability.id}'`, entry.loc);
-    }
-    if (!realized.has(capabilityId)) {
-      pushError(errors, `Projection ${statement.id} delete_semantics for '${capabilityId}' must also appear in 'realizes'`, entry.loc);
-    }
-
-    const directives = new Map();
-    for (let i = 1; i < tokens.length; i += 2) {
-      const key = tokens[i];
-      const value = tokens[i + 1];
-      if (!value) {
-        pushError(errors, `Projection ${statement.id} delete_semantics for '${capabilityId}' is missing a value for '${key}'`, entry.loc);
-        continue;
-      }
-      directives.set(key, value);
-    }
-
-    for (const requiredKey of ["mode", "response"]) {
-      if (!directives.has(requiredKey)) {
-        pushError(errors, `Projection ${statement.id} delete_semantics for '${capabilityId}' must include '${requiredKey}'`, entry.loc);
-      }
-    }
-
-    for (const key of directives.keys()) {
-      if (!["mode", "field", "value", "response"].includes(key)) {
-        pushError(errors, `Projection ${statement.id} delete_semantics for '${capabilityId}' has unknown directive '${key}'`, entry.loc);
-      }
-    }
-
-    const mode = directives.get("mode");
-    if (mode && !["soft", "hard"].includes(mode)) {
-      pushError(errors, `Projection ${statement.id} delete_semantics for '${capabilityId}' has invalid mode '${mode}'`, entry.loc);
-    }
-
-    const response = directives.get("response");
-    if (response && !["none", "body"].includes(response)) {
-      pushError(errors, `Projection ${statement.id} delete_semantics for '${capabilityId}' has invalid response '${response}'`, entry.loc);
-    }
-
-    if (mode === "soft") {
-      if (!directives.has("field") || !directives.has("value")) {
-        pushError(errors, `Projection ${statement.id} delete_semantics for '${capabilityId}' must include 'field' and 'value' for soft deletes`, entry.loc);
-      }
-      const outputFields = resolveCapabilityContractFields(registry, capabilityId, "output");
-      const fieldName = directives.get("field");
-      if (fieldName && outputFields.size > 0 && !outputFields.has(fieldName)) {
-        pushError(errors, `Projection ${statement.id} delete_semantics references unknown output field '${fieldName}' on ${capabilityId}`, entry.loc);
-      }
-    }
-  }
-}
-
-function validateProjectionHttpAsync(errors, statement, fieldMap, registry) {
-  if (statement.kind !== "projection") {
-    return;
-  }
-
-  const httpAsyncField = fieldMap.get("async_jobs")?.[0];
-  if (!httpAsyncField || httpAsyncField.value.type !== "block") {
-    return;
-  }
-
-  const realized = new Set(symbolValues(getFieldValue(statement, "realizes")));
-  const httpEntries = blockEntries(getFieldValue(statement, "endpoints"));
-  const httpDirectivesByCapability = new Map();
-  for (const entry of httpEntries) {
-    const tokens = blockSymbolItems(entry).map((item) => item.value);
-    const capabilityId = tokens[0];
-    const directives = new Map();
-    for (let i = 1; i < tokens.length - 1; i += 2) {
-      directives.set(tokens[i], tokens[i + 1]);
-    }
-    httpDirectivesByCapability.set(capabilityId, directives);
-  }
-  for (const entry of httpAsyncField.value.entries) {
-    const tokens = blockSymbolItems(entry).map((item) => item.value);
-    const [capabilityId] = tokens;
-    const capability = registry.get(capabilityId);
-
-    if (!capability) {
-      pushError(errors, `Projection ${statement.id} async_jobs references missing capability '${capabilityId}'`, entry.loc);
-      continue;
-    }
-    if (capability.kind !== "capability") {
-      pushError(errors, `Projection ${statement.id} async_jobs must target a capability, found ${capability.kind} '${capability.id}'`, entry.loc);
-    }
-    if (!realized.has(capabilityId)) {
-      pushError(errors, `Projection ${statement.id} async_jobs for '${capabilityId}' must also appear in 'realizes'`, entry.loc);
-    }
-
-    const directives = new Map();
-    for (let i = 1; i < tokens.length; i += 2) {
-      const key = tokens[i];
-      const value = tokens[i + 1];
-      if (!value) {
-        pushError(errors, `Projection ${statement.id} async_jobs for '${capabilityId}' is missing a value for '${key}'`, entry.loc);
-        continue;
-      }
-      directives.set(key, value);
-    }
-
-    for (const requiredKey of ["mode", "accepted", "location_header", "retry_after_header", "status_path", "status_capability", "job"]) {
-      if (!directives.has(requiredKey)) {
-        pushError(errors, `Projection ${statement.id} async_jobs for '${capabilityId}' must include '${requiredKey}'`, entry.loc);
-      }
-    }
-
-    for (const key of directives.keys()) {
-      if (!["mode", "accepted", "location_header", "retry_after_header", "status_path", "status_capability", "job"].includes(key)) {
-        pushError(errors, `Projection ${statement.id} async_jobs for '${capabilityId}' has unknown directive '${key}'`, entry.loc);
-      }
-    }
-
-    const mode = directives.get("mode");
-    if (mode && mode !== "job") {
-      pushError(errors, `Projection ${statement.id} async_jobs for '${capabilityId}' has invalid mode '${mode}'`, entry.loc);
-    }
-
-    const accepted = directives.get("accepted");
-    if (accepted && accepted !== "202") {
-      pushError(errors, `Projection ${statement.id} async_jobs for '${capabilityId}' must use 202 for 'accepted'`, entry.loc);
-    }
-
-    const jobShapeId = directives.get("job");
-    if (jobShapeId) {
-      const jobShape = registry.get(jobShapeId);
-      if (!jobShape) {
-        pushError(errors, `Projection ${statement.id} async_jobs for '${capabilityId}' references missing shape '${jobShapeId}'`, entry.loc);
-      } else if (jobShape.kind !== "shape") {
-        pushError(errors, `Projection ${statement.id} async_jobs for '${capabilityId}' must reference a shape for 'job', found ${jobShape.kind} '${jobShape.id}'`, entry.loc);
-      }
-    }
-
-    const statusCapabilityId = directives.get("status_capability");
-    if (statusCapabilityId) {
-      const statusCapability = registry.get(statusCapabilityId);
-      if (!statusCapability) {
-        pushError(errors, `Projection ${statement.id} async_jobs for '${capabilityId}' references missing status capability '${statusCapabilityId}'`, entry.loc);
-      } else if (statusCapability.kind !== "capability") {
-        pushError(errors, `Projection ${statement.id} async_jobs for '${capabilityId}' must reference a capability for 'status_capability', found ${statusCapability.kind} '${statusCapability.id}'`, entry.loc);
-      } else if (!realized.has(statusCapabilityId)) {
-        pushError(errors, `Projection ${statement.id} async_jobs for '${capabilityId}' status capability '${statusCapabilityId}' must also appear in 'realizes'`, entry.loc);
-      }
-
-      const statusHttp = httpDirectivesByCapability.get(statusCapabilityId);
-      if (statusHttp?.get("method") && statusHttp.get("method") !== "GET") {
-        pushError(errors, `Projection ${statement.id} async_jobs for '${capabilityId}' status capability '${statusCapabilityId}' must use HTTP GET`, entry.loc);
-      }
-      if (statusHttp?.get("path") && directives.get("status_path") && statusHttp.get("path") !== directives.get("status_path")) {
-        pushError(errors, `Projection ${statement.id} async_jobs for '${capabilityId}' status_path must match the path for '${statusCapabilityId}'`, entry.loc);
-      }
-    }
-
-    const statusPath = directives.get("status_path");
-    if (statusPath && !statusPath.startsWith("/")) {
-      pushError(errors, `Projection ${statement.id} async_jobs for '${capabilityId}' must use an absolute path for 'status_path'`, entry.loc);
-    }
-  }
-}
-
-function validateProjectionHttpStatus(errors, statement, fieldMap, registry) {
-  if (statement.kind !== "projection") {
-    return;
-  }
-
-  const httpStatusField = fieldMap.get("async_status")?.[0];
-  if (!httpStatusField || httpStatusField.value.type !== "block") {
-    return;
-  }
-
-  const realized = new Set(symbolValues(getFieldValue(statement, "realizes")));
-  const httpEntries = blockEntries(getFieldValue(statement, "endpoints"));
-  const httpMethodsByCapability = new Map();
-  for (const entry of httpEntries) {
-    const tokens = blockSymbolItems(entry).map((item) => item.value);
-    const capabilityId = tokens[0];
-    for (let i = 1; i < tokens.length - 1; i += 2) {
-      if (tokens[i] === "method") {
-        httpMethodsByCapability.set(capabilityId, tokens[i + 1]);
-        break;
-      }
-    }
-  }
-  for (const entry of httpStatusField.value.entries) {
-    const tokens = blockSymbolItems(entry).map((item) => item.value);
-    const [capabilityId] = tokens;
-    const capability = registry.get(capabilityId);
-
-    if (!capability) {
-      pushError(errors, `Projection ${statement.id} async_status references missing capability '${capabilityId}'`, entry.loc);
-      continue;
-    }
-    if (capability.kind !== "capability") {
-      pushError(errors, `Projection ${statement.id} async_status must target a capability, found ${capability.kind} '${capability.id}'`, entry.loc);
-    }
-    if (!realized.has(capabilityId)) {
-      pushError(errors, `Projection ${statement.id} async_status for '${capabilityId}' must also appear in 'realizes'`, entry.loc);
-    }
-
-    const directives = new Map();
-    for (let i = 1; i < tokens.length; i += 2) {
-      const key = tokens[i];
-      const value = tokens[i + 1];
-      if (!value) {
-        pushError(errors, `Projection ${statement.id} async_status for '${capabilityId}' is missing a value for '${key}'`, entry.loc);
-        continue;
-      }
-      directives.set(key, value);
-    }
-
-    for (const requiredKey of ["async_for", "state_field", "completed", "failed"]) {
-      if (!directives.has(requiredKey)) {
-        pushError(errors, `Projection ${statement.id} async_status for '${capabilityId}' must include '${requiredKey}'`, entry.loc);
-      }
-    }
-
-    for (const key of directives.keys()) {
-      if (!["async_for", "state_field", "completed", "failed", "expired", "download_capability", "download_field", "error_field"].includes(key)) {
-        pushError(errors, `Projection ${statement.id} async_status for '${capabilityId}' has unknown directive '${key}'`, entry.loc);
-      }
-    }
-
-    const asyncCapabilityId = directives.get("async_for");
-    if (asyncCapabilityId) {
-      const asyncCapability = registry.get(asyncCapabilityId);
-      if (!asyncCapability) {
-        pushError(errors, `Projection ${statement.id} async_status for '${capabilityId}' references missing async capability '${asyncCapabilityId}'`, entry.loc);
-      } else if (asyncCapability.kind !== "capability") {
-        pushError(errors, `Projection ${statement.id} async_status for '${capabilityId}' must reference a capability for 'async_for', found ${asyncCapability.kind} '${asyncCapability.id}'`, entry.loc);
-      } else if (!realized.has(asyncCapabilityId)) {
-        pushError(errors, `Projection ${statement.id} async_status for '${capabilityId}' async capability '${asyncCapabilityId}' must also appear in 'realizes'`, entry.loc);
-      }
-    }
-
-    const outputFields = resolveCapabilityContractFields(registry, capabilityId, "output");
-    for (const [directive, fieldName] of [
-      ["state_field", directives.get("state_field")],
-      ["download_field", directives.get("download_field")],
-      ["error_field", directives.get("error_field")]
-    ]) {
-      if (fieldName && outputFields.size > 0 && !outputFields.has(fieldName)) {
-        pushError(errors, `Projection ${statement.id} async_status references unknown output field '${fieldName}' for '${directive}' on ${capabilityId}`, entry.loc);
-      }
-    }
-
-    const downloadCapabilityId = directives.get("download_capability");
-    if (downloadCapabilityId) {
-      const downloadCapability = registry.get(downloadCapabilityId);
-      if (!downloadCapability) {
-        pushError(errors, `Projection ${statement.id} async_status for '${capabilityId}' references missing download capability '${downloadCapabilityId}'`, entry.loc);
-      } else if (downloadCapability.kind !== "capability") {
-        pushError(errors, `Projection ${statement.id} async_status for '${capabilityId}' must reference a capability for 'download_capability', found ${downloadCapability.kind} '${downloadCapability.id}'`, entry.loc);
-      } else if (!realized.has(downloadCapabilityId)) {
-        pushError(errors, `Projection ${statement.id} async_status for '${capabilityId}' download capability '${downloadCapabilityId}' must also appear in 'realizes'`, entry.loc);
-      }
-
-      const method = httpMethodsByCapability.get(downloadCapabilityId);
-      if (method && method !== "GET") {
-        pushError(errors, `Projection ${statement.id} async_status for '${capabilityId}' download capability '${downloadCapabilityId}' must use HTTP GET`, entry.loc);
-      }
-    }
-  }
-}
-
-function validateProjectionHttpDownload(errors, statement, fieldMap, registry) {
-  if (statement.kind !== "projection") {
-    return;
-  }
-
-  const httpDownloadField = fieldMap.get("downloads")?.[0];
-  if (!httpDownloadField || httpDownloadField.value.type !== "block") {
-    return;
-  }
-
-  const realized = new Set(symbolValues(getFieldValue(statement, "realizes")));
-  for (const entry of httpDownloadField.value.entries) {
-    const tokens = blockSymbolItems(entry).map((item) => item.value);
-    const [capabilityId] = tokens;
-    const capability = registry.get(capabilityId);
-
-    if (!capability) {
-      pushError(errors, `Projection ${statement.id} downloads references missing capability '${capabilityId}'`, entry.loc);
-      continue;
-    }
-    if (capability.kind !== "capability") {
-      pushError(errors, `Projection ${statement.id} downloads must target a capability, found ${capability.kind} '${capability.id}'`, entry.loc);
-    }
-    if (!realized.has(capabilityId)) {
-      pushError(errors, `Projection ${statement.id} downloads for '${capabilityId}' must also appear in 'realizes'`, entry.loc);
-    }
-
-    const directives = new Map();
-    for (let i = 1; i < tokens.length; i += 2) {
-      const key = tokens[i];
-      const value = tokens[i + 1];
-      if (!value) {
-        pushError(errors, `Projection ${statement.id} downloads for '${capabilityId}' is missing a value for '${key}'`, entry.loc);
-        continue;
-      }
-      directives.set(key, value);
-    }
-
-    for (const requiredKey of ["async_for", "media", "disposition"]) {
-      if (!directives.has(requiredKey)) {
-        pushError(errors, `Projection ${statement.id} downloads for '${capabilityId}' must include '${requiredKey}'`, entry.loc);
-      }
-    }
-
-    for (const key of directives.keys()) {
-      if (!["async_for", "media", "filename", "disposition"].includes(key)) {
-        pushError(errors, `Projection ${statement.id} downloads for '${capabilityId}' has unknown directive '${key}'`, entry.loc);
-      }
-    }
-
-    const asyncCapabilityId = directives.get("async_for");
-    if (asyncCapabilityId) {
-      const asyncCapability = registry.get(asyncCapabilityId);
-      if (!asyncCapability) {
-        pushError(errors, `Projection ${statement.id} downloads for '${capabilityId}' references missing async capability '${asyncCapabilityId}'`, entry.loc);
-      } else if (asyncCapability.kind !== "capability") {
-        pushError(errors, `Projection ${statement.id} downloads for '${capabilityId}' must reference a capability for 'async_for', found ${asyncCapability.kind} '${asyncCapability.id}'`, entry.loc);
-      } else if (!realized.has(asyncCapabilityId)) {
-        pushError(errors, `Projection ${statement.id} downloads for '${capabilityId}' async capability '${asyncCapabilityId}' must also appear in 'realizes'`, entry.loc);
-      }
-    }
-
-    const media = directives.get("media");
-    if (media && !media.includes("/")) {
-      pushError(errors, `Projection ${statement.id} downloads for '${capabilityId}' must use a valid media type`, entry.loc);
-    }
-
-    const disposition = directives.get("disposition");
-    if (disposition && !["attachment", "inline"].includes(disposition)) {
-      pushError(errors, `Projection ${statement.id} downloads for '${capabilityId}' has invalid disposition '${disposition}'`, entry.loc);
-    }
-  }
-}
-
-function validateProjectionHttpAuthz(errors, statement, fieldMap, registry) {
-  if (statement.kind !== "projection") {
-    return;
-  }
-
-  const httpAuthzField = fieldMap.get("authorization")?.[0];
-  if (!httpAuthzField || httpAuthzField.value.type !== "block") {
-    return;
-  }
-
-  const realized = new Set(symbolValues(getFieldValue(statement, "realizes")));
-  for (const entry of httpAuthzField.value.entries) {
-    const tokens = blockSymbolItems(entry).map((item) => item.value);
-    const [capabilityId] = tokens;
-    const capability = registry.get(capabilityId);
-
-    if (!capability) {
-      pushError(errors, `Projection ${statement.id} authorization references missing capability '${capabilityId}'`, entry.loc);
-      continue;
-    }
-    if (capability.kind !== "capability") {
-      pushError(errors, `Projection ${statement.id} authorization must target a capability, found ${capability.kind} '${capability.id}'`, entry.loc);
-    }
-    if (!realized.has(capabilityId)) {
-      pushError(errors, `Projection ${statement.id} authorization for '${capabilityId}' must also appear in 'realizes'`, entry.loc);
-    }
-
-    const directives = new Map();
-    for (let i = 1; i < tokens.length; i += 2) {
-      const key = tokens[i];
-      const value = tokens[i + 1];
-      if (!value) {
-        pushError(errors, `Projection ${statement.id} authorization for '${capabilityId}' is missing a value for '${key}'`, entry.loc);
-        continue;
-      }
-      directives.set(key, value);
-    }
-
-    for (const key of directives.keys()) {
-      if (!["role", "permission", "claim", "claim_value", "ownership", "ownership_field"].includes(key)) {
-        pushError(errors, `Projection ${statement.id} authorization for '${capabilityId}' has unknown directive '${key}'`, entry.loc);
-      }
-    }
-
-    if (directives.size === 0) {
-      pushError(errors, `Projection ${statement.id} authorization for '${capabilityId}' must include at least one directive`, entry.loc);
-    }
-
-    const ownership = directives.get("ownership");
-    if (ownership && !["owner", "owner_or_admin", "project_member", "none"].includes(ownership)) {
-      pushError(errors, `Projection ${statement.id} authorization for '${capabilityId}' has invalid ownership '${ownership}'`, entry.loc);
-    }
-
-    const ownershipField = directives.get("ownership_field");
-    if (ownershipField && (!ownership || ownership === "none")) {
-      pushError(errors, `Projection ${statement.id} authorization for '${capabilityId}' cannot declare ownership_field without ownership`, entry.loc);
-    }
-
-    const claimValue = directives.get("claim_value");
-    if (claimValue && !directives.get("claim")) {
-      pushError(errors, `Projection ${statement.id} authorization for '${capabilityId}' cannot declare claim_value without claim`, entry.loc);
-    }
-  }
-}
-
-function validateProjectionHttpCallbacks(errors, statement, fieldMap, registry) {
-  if (statement.kind !== "projection") {
-    return;
-  }
-
-  const httpCallbacksField = fieldMap.get("callbacks")?.[0];
-  if (!httpCallbacksField || httpCallbacksField.value.type !== "block") {
-    return;
-  }
-
-  const realized = new Set(symbolValues(getFieldValue(statement, "realizes")));
-  for (const entry of httpCallbacksField.value.entries) {
-    const tokens = blockSymbolItems(entry).map((item) => item.value);
-    const [capabilityId] = tokens;
-    const capability = registry.get(capabilityId);
-
-    if (!capability) {
-      pushError(errors, `Projection ${statement.id} callbacks references missing capability '${capabilityId}'`, entry.loc);
-      continue;
-    }
-    if (capability.kind !== "capability") {
-      pushError(errors, `Projection ${statement.id} callbacks must target a capability, found ${capability.kind} '${capability.id}'`, entry.loc);
-    }
-    if (!realized.has(capabilityId)) {
-      pushError(errors, `Projection ${statement.id} callbacks for '${capabilityId}' must also appear in 'realizes'`, entry.loc);
-    }
-
-    const directives = new Map();
-    for (let i = 1; i < tokens.length; i += 2) {
-      const key = tokens[i];
-      const value = tokens[i + 1];
-      if (!value) {
-        pushError(errors, `Projection ${statement.id} callbacks for '${capabilityId}' is missing a value for '${key}'`, entry.loc);
-        continue;
-      }
-      directives.set(key, value);
-    }
-
-    for (const requiredKey of ["event", "target_field", "method", "payload", "success"]) {
-      if (!directives.has(requiredKey)) {
-        pushError(errors, `Projection ${statement.id} callbacks for '${capabilityId}' must include '${requiredKey}'`, entry.loc);
-      }
-    }
-
-    for (const key of directives.keys()) {
-      if (!["event", "target_field", "method", "payload", "success"].includes(key)) {
-        pushError(errors, `Projection ${statement.id} callbacks for '${capabilityId}' has unknown directive '${key}'`, entry.loc);
-      }
-    }
-
-    const method = directives.get("method");
-    if (method && !["POST", "PUT", "PATCH"].includes(method)) {
-      pushError(errors, `Projection ${statement.id} callbacks for '${capabilityId}' has invalid method '${method}'`, entry.loc);
-    }
-
-    const success = directives.get("success");
-    if (success && !/^\d{3}$/.test(success)) {
-      pushError(errors, `Projection ${statement.id} callbacks for '${capabilityId}' must use a 3-digit success status`, entry.loc);
-    }
-
-    const payloadShapeId = directives.get("payload");
-    if (payloadShapeId) {
-      const payloadShape = registry.get(payloadShapeId);
-      if (!payloadShape) {
-        pushError(errors, `Projection ${statement.id} callbacks for '${capabilityId}' references missing shape '${payloadShapeId}'`, entry.loc);
-      } else if (payloadShape.kind !== "shape") {
-        pushError(errors, `Projection ${statement.id} callbacks for '${capabilityId}' must reference a shape for 'payload', found ${payloadShape.kind} '${payloadShape.id}'`, entry.loc);
-      }
-    }
-
-    const targetField = directives.get("target_field");
-    const inputFields = resolveCapabilityContractFields(registry, capabilityId, "input");
-    if (targetField && inputFields.size > 0 && !inputFields.has(targetField)) {
-      pushError(errors, `Projection ${statement.id} callbacks references unknown input field '${targetField}' on ${capabilityId}`, entry.loc);
-    }
-  }
-}
-
-function parseProjectionHttpResponsesDirectives(tokens) {
-  const result = {
-    mode: null,
-    item: null,
-    cursor: null,
-    limit: null,
-    sort: null,
-    total: null,
-    errors: []
-  };
-
-  for (let i = 0; i < tokens.length; i += 1) {
-    const token = tokens[i];
-    if (token === "mode") {
-      result.mode = tokens[i + 1] || null;
-      if (!tokens[i + 1]) {
-        result.errors.push("is missing a value for 'mode'");
-      }
-      i += 1;
-      continue;
-    }
-    if (token === "item") {
-      result.item = tokens[i + 1] || null;
-      if (!tokens[i + 1]) {
-        result.errors.push("is missing a value for 'item'");
-      }
-      i += 1;
-      continue;
-    }
-    if (token === "cursor") {
-      const requestKeyword = tokens[i + 1];
-      const requestField = tokens[i + 2];
-      const responseKeyword = tokens[i + 3];
-      const responseNext = tokens[i + 4];
-      let responsePrev = null;
-      let consumed = 4;
-      if (tokens[i + 5] === "response_prev") {
-        responsePrev = tokens[i + 6] || null;
-        consumed = 6;
-      }
-      result.cursor = {
-        requestAfter: requestKeyword === "request_after" ? requestField : null,
-        responseNext: responseKeyword === "response_next" ? responseNext : null,
-        responsePrev
-      };
-      if (requestKeyword !== "request_after") {
-        result.errors.push("must use 'cursor request_after <field>'");
-      }
-      if (responseKeyword !== "response_next") {
-        result.errors.push("must use 'cursor response_next <wire_name>'");
-      }
-      i += consumed;
-      continue;
-    }
-    if (token === "limit") {
-      result.limit = {
-        field: tokens[i + 1] === "field" ? tokens[i + 2] || null : null,
-        defaultValue: tokens[i + 3] === "default" ? tokens[i + 4] || null : null,
-        maxValue: tokens[i + 5] === "max" ? tokens[i + 6] || null : null
-      };
-      if (tokens[i + 1] !== "field" || tokens[i + 3] !== "default" || tokens[i + 5] !== "max") {
-        result.errors.push("must use 'limit field <field> default <n> max <n>'");
-      }
-      i += 6;
-      continue;
-    }
-    if (token === "sort") {
-      result.sort = {
-        field: tokens[i + 1] === "by" ? tokens[i + 2] || null : null,
-        direction: tokens[i + 3] === "direction" ? tokens[i + 4] || null : null
-      };
-      if (tokens[i + 1] !== "by" || tokens[i + 3] !== "direction") {
-        result.errors.push("must use 'sort by <field> direction <asc|desc>'");
-      }
-      i += 4;
-      continue;
-    }
-    if (token === "total") {
-      result.total = {
-        included: tokens[i + 1] === "included" ? tokens[i + 2] || null : null
-      };
-      if (tokens[i + 1] !== "included") {
-        result.errors.push("must use 'total included <true|false>'");
-      }
-      i += 2;
-      continue;
-    }
-
-    result.errors.push(`has unknown directive '${token}'`);
-  }
-
-  return result;
-}
-
-function resolveCapabilityOutputShape(registry, capabilityId) {
-  const capability = registry.get(capabilityId);
-  if (!capability || capability.kind !== "capability") {
-    return null;
-  }
-
-  const shapeId = symbolValues(getFieldValue(capability, "output"))[0];
-  const shape = shapeId ? registry.get(shapeId) : null;
-  return shape?.kind === "shape" ? shape : null;
-}
-
-function collectProjectionUiScreens(statement, fieldMap) {
-  const screensField = fieldMap.get("screens")?.[0];
-  if (!screensField || screensField.value.type !== "block") {
-    return new Map();
-  }
-
-  const screens = new Map();
-  for (const entry of screensField.value.entries) {
-    const tokens = blockSymbolItems(entry).map((item) => item.value);
-    if (tokens[0] === "screen" && tokens[1]) {
-      screens.set(tokens[1], entry);
-    }
-  }
-  return screens;
-}
-
-function resolveProjectionUiScreenFieldNames(registry, screenEntry, statement) {
-  const tokens = blockSymbolItems(screenEntry).map((item) => item.value);
-  const directives = parseUiDirectiveMap(tokens, 2, [], statement, screenEntry, "");
-  const kind = directives.get("kind");
-
-  if (kind === "form") {
-    const shapeId = directives.get("input_shape");
-    const shape = shapeId ? registry.get(shapeId) : null;
-    if (!shape || shape.kind !== "shape") {
-      return new Set();
-    }
-    const explicitFields = statementFieldNames(shape);
-    return new Set(explicitFields.length > 0 ? explicitFields : resolveShapeBaseFieldNames(shape, registry));
-  }
-
-  if (kind === "list") {
-    const loadCapabilityId = directives.get("load");
-    return loadCapabilityId ? resolveCapabilityContractFields(registry, loadCapabilityId, "input") : new Set();
-  }
-
-  if (kind === "detail" || kind === "job_status") {
-    const loadCapabilityId = directives.get("load");
-    return loadCapabilityId ? resolveCapabilityContractFields(registry, loadCapabilityId, "output") : new Set();
-  }
-
-  return new Set();
-}
-
-function screenIdsFromProjectionStatement(statement) {
-  const screens = new Set();
-  for (const entry of blockEntries(getFieldValue(statement, "screens"))) {
-    const tokens = blockSymbolItems(entry).map((item) => item.value);
-    if (tokens[0] === "screen" && tokens[1]) {
-      screens.add(tokens[1]);
-    }
-  }
-  return screens;
-}
-
-function collectAvailableUiScreenIds(statement, fieldMap, registry) {
-  const available = new Set(collectProjectionUiScreens(statement, fieldMap).keys());
-  for (const targetId of symbolValues(getFieldValue(statement, "realizes"))) {
-    const target = registry.get(targetId);
-    if (target?.kind === "projection") {
-      for (const screenId of screenIdsFromProjectionStatement(target)) {
-        available.add(screenId);
-      }
-    }
-  }
-  return available;
-}
-
-function collectProjectionUiRegionKeys(statement) {
-  const keys = new Set();
-  for (const entry of blockEntries(getFieldValue(statement, "screen_regions"))) {
-    const tokens = blockSymbolItems(entry).map((item) => item.value);
-    if (tokens[0] === "screen" && tokens[1] && tokens[2] === "region" && tokens[3]) {
-      keys.add(`${tokens[1]}:${tokens[3]}`);
-    }
-  }
-  return keys;
-}
-
-function collectAvailableUiRegionKeys(statement, registry) {
-  const available = collectProjectionUiRegionKeys(statement);
-  for (const targetId of symbolValues(getFieldValue(statement, "realizes"))) {
-    const target = registry.get(targetId);
-    if (target?.kind === "projection") {
-      for (const key of collectProjectionUiRegionKeys(target)) {
-        available.add(key);
-      }
-    }
-  }
-  return available;
-}
-
-function collectProjectionUiRegionPatterns(statement) {
-  const patterns = new Map();
-  for (const entry of blockEntries(getFieldValue(statement, "screen_regions"))) {
-    const tokens = blockSymbolItems(entry).map((item) => item.value);
-    if (tokens[0] !== "screen" || !tokens[1] || tokens[2] !== "region" || !tokens[3]) {
-      continue;
-    }
-    for (let i = 4; i < tokens.length; i += 2) {
-      if (tokens[i] === "pattern" && tokens[i + 1]) {
-        patterns.set(`${tokens[1]}:${tokens[3]}`, tokens[i + 1]);
-      }
-    }
-  }
-  return patterns;
-}
-
-function collectAvailableUiRegionPatterns(statement, registry) {
-  const patterns = collectProjectionUiRegionPatterns(statement);
-  for (const targetId of symbolValues(getFieldValue(statement, "realizes"))) {
-    const target = registry.get(targetId);
-    if (target?.kind !== "projection") {
-      continue;
-    }
-    for (const [key, pattern] of collectProjectionUiRegionPatterns(target)) {
-      if (!patterns.has(key)) {
-        patterns.set(key, pattern);
-      }
-    }
-  }
-  return patterns;
-}
-
-function parseUiDirectiveMap(tokens, startIndex, errors, statement, entry, context) {
-  const directives = new Map();
-
-  for (let i = startIndex; i < tokens.length; i += 2) {
-    const key = tokens[i];
-    const value = tokens[i + 1];
-    if (!key) {
-      continue;
-    }
-    if (!value) {
-      pushError(errors, `Projection ${statement.id} ${context} is missing a value for '${key}'`, entry.loc);
-      continue;
-    }
-    directives.set(key, value);
-  }
-
-  return directives;
-}
-
-function validateProjectionUiScreens(errors, statement, fieldMap, registry) {
-  if (statement.kind !== "projection") {
-    return;
-  }
-
-  const screensField = fieldMap.get("screens")?.[0];
-  if (!screensField || screensField.value.type !== "block") {
-    return;
-  }
-
-  const realized = new Set(symbolValues(getFieldValue(statement, "realizes")));
-  const seenScreens = new Set();
-
-  for (const entry of screensField.value.entries) {
-    const tokens = blockSymbolItems(entry).map((item) => item.value);
-    const [keyword, screenId] = tokens;
-
-    if (keyword !== "screen") {
-      pushError(errors, `Projection ${statement.id} screens entries must start with 'screen'`, entry.loc);
-      continue;
-    }
-    if (!screenId) {
-      pushError(errors, `Projection ${statement.id} screens entries must include a screen id`, entry.loc);
-      continue;
-    }
-    if (!IDENTIFIER_PATTERN.test(screenId)) {
-      pushError(errors, `Projection ${statement.id} screens has invalid screen id '${screenId}'`, entry.loc);
-    }
-    if (seenScreens.has(screenId)) {
-      pushError(errors, `Projection ${statement.id} screens has duplicate screen id '${screenId}'`, entry.loc);
-    }
-    seenScreens.add(screenId);
-
-    const directives = parseUiDirectiveMap(tokens, 2, errors, statement, entry, `screens for '${screenId}'`);
-    const kind = directives.get("kind");
-    if (!kind) {
-      pushError(errors, `Projection ${statement.id} screens for '${screenId}' must include 'kind'`, entry.loc);
-    }
-    if (kind && !UI_SCREEN_KINDS.has(kind)) {
-      pushError(errors, `Projection ${statement.id} screens for '${screenId}' has invalid kind '${kind}'`, entry.loc);
-    }
-
-    for (const key of directives.keys()) {
-      if (!["kind", "title", "load", "item_shape", "view_shape", "input_shape", "submit", "detail_capability", "primary_action", "secondary_action", "destructive_action", "success_navigate", "success_refresh", "empty_title", "empty_body", "terminal_action", "loading_state", "error_state", "unauthorized_state", "not_found_state", "success_state"].includes(key)) {
-        pushError(errors, `Projection ${statement.id} screens for '${screenId}' has unknown directive '${key}'`, entry.loc);
-      }
-    }
-
-    for (const [key, expectedKind] of [
-      ["load", "capability"],
-      ["submit", "capability"],
-      ["detail_capability", "capability"],
-      ["primary_action", "capability"],
-      ["secondary_action", "capability"],
-      ["destructive_action", "capability"],
-      ["terminal_action", "capability"],
-      ["item_shape", "shape"],
-      ["view_shape", "shape"],
-      ["input_shape", "shape"]
-    ]) {
-      const targetId = directives.get(key);
-      if (!targetId) {
-        continue;
-      }
-      const target = registry.get(targetId);
-      if (!target) {
-        pushError(errors, `Projection ${statement.id} screens for '${screenId}' references missing ${expectedKind} '${targetId}' for '${key}'`, entry.loc);
-        continue;
-      }
-      if (target.kind !== expectedKind) {
-        pushError(errors, `Projection ${statement.id} screens for '${screenId}' must reference a ${expectedKind} for '${key}', found ${target.kind} '${target.id}'`, entry.loc);
-      }
-      if (expectedKind === "capability" && !realized.has(targetId)) {
-        pushError(errors, `Projection ${statement.id} screens for '${screenId}' capability '${targetId}' for '${key}' must also appear in 'realizes'`, entry.loc);
-      }
-    }
-
-    const successNavigate = directives.get("success_navigate");
-    const successRefresh = directives.get("success_refresh");
-    if (successNavigate && !IDENTIFIER_PATTERN.test(successNavigate)) {
-      pushError(errors, `Projection ${statement.id} screens for '${screenId}' has invalid target '${successNavigate}' for 'success_navigate'`, entry.loc);
-    }
-    if (successRefresh && !IDENTIFIER_PATTERN.test(successRefresh)) {
-      pushError(errors, `Projection ${statement.id} screens for '${screenId}' has invalid target '${successRefresh}' for 'success_refresh'`, entry.loc);
-    }
-
-    if (kind === "list" && !directives.get("load")) {
-      pushError(errors, `Projection ${statement.id} screens for '${screenId}' kind 'list' requires 'load'`, entry.loc);
-    }
-    if (kind === "detail") {
-      if (!directives.get("load")) {
-        pushError(errors, `Projection ${statement.id} screens for '${screenId}' kind 'detail' requires 'load'`, entry.loc);
-      }
-      if (!directives.get("view_shape")) {
-        pushError(errors, `Projection ${statement.id} screens for '${screenId}' kind 'detail' requires 'view_shape'`, entry.loc);
-      }
-    }
-    if (kind === "form") {
-      if (!directives.get("input_shape")) {
-        pushError(errors, `Projection ${statement.id} screens for '${screenId}' kind 'form' requires 'input_shape'`, entry.loc);
-      }
-      if (!directives.get("submit")) {
-        pushError(errors, `Projection ${statement.id} screens for '${screenId}' kind 'form' requires 'submit'`, entry.loc);
-      }
-    }
-  }
-
-  for (const entry of screensField.value.entries) {
-    const tokens = blockSymbolItems(entry).map((item) => item.value);
-    const screenId = tokens[1];
-    if (!screenId) {
-      continue;
-    }
-    const directives = parseUiDirectiveMap(tokens, 2, [], statement, entry, "");
-    for (const key of ["success_navigate", "success_refresh"]) {
-      const targetScreenId = directives.get(key);
-      if (targetScreenId && !seenScreens.has(targetScreenId)) {
-        pushError(errors, `Projection ${statement.id} screens for '${screenId}' references unknown screen '${targetScreenId}' for '${key}'`, entry.loc);
-      }
-    }
-  }
-}
-
-function validateProjectionUiCollections(errors, statement, fieldMap, registry) {
-  if (statement.kind !== "projection") {
-    return;
-  }
-
-  const collectionsField = fieldMap.get("collection_views")?.[0];
-  if (!collectionsField || collectionsField.value.type !== "block") {
-    return;
-  }
-
-  const screens = collectProjectionUiScreens(statement, fieldMap);
-  for (const entry of collectionsField.value.entries) {
-    const tokens = blockSymbolItems(entry).map((item) => item.value);
-    const [keyword, screenId, operation, value, extra] = tokens;
-
-    if (keyword !== "screen") {
-      pushError(errors, `Projection ${statement.id} collection_views entries must start with 'screen'`, entry.loc);
-      continue;
-    }
-    const screenEntry = screens.get(screenId);
-    if (!screenEntry) {
-      pushError(errors, `Projection ${statement.id} collection_views references unknown screen '${screenId}'`, entry.loc);
-      continue;
-    }
-
-    const screenTokens = blockSymbolItems(screenEntry).map((item) => item.value);
-    const screenDirectives = parseUiDirectiveMap(screenTokens, 2, [], statement, screenEntry, "");
-    if (screenDirectives.get("kind") !== "list") {
-      pushError(errors, `Projection ${statement.id} collection_views may only target list screens, found '${screenId}'`, entry.loc);
-    }
-
-    if (!["filter", "search", "pagination", "sort", "group", "view", "refresh"].includes(operation)) {
-      pushError(errors, `Projection ${statement.id} collection_views for '${screenId}' has invalid operation '${operation}'`, entry.loc);
-      continue;
-    }
-
-    const loadCapabilityId = screenDirectives.get("load");
-    const inputFields = loadCapabilityId ? resolveCapabilityContractFields(registry, loadCapabilityId, "input") : new Set();
-    const outputShape = loadCapabilityId ? resolveCapabilityOutputShape(registry, loadCapabilityId) : null;
-    const outputFields = outputShape
-      ? new Set((statementFieldNames(outputShape).length > 0 ? statementFieldNames(outputShape) : resolveShapeBaseFieldNames(outputShape, registry)))
-      : new Set();
-
-    if (operation === "filter" || operation === "search") {
-      if (!value) {
-        pushError(errors, `Projection ${statement.id} collection_views for '${screenId}' must include a field for '${operation}'`, entry.loc);
-      } else if (inputFields.size > 0 && !inputFields.has(value)) {
-        pushError(errors, `Projection ${statement.id} collection_views references unknown input field '${value}' for '${operation}' on '${screenId}'`, entry.loc);
-      }
-    }
-
-    if (operation === "pagination" && !["cursor", "paged", "none"].includes(value || "")) {
-      pushError(errors, `Projection ${statement.id} collection_views for '${screenId}' has invalid pagination '${value}'`, entry.loc);
-    }
-
-    if (operation === "sort") {
-      if (!value || !extra) {
-        pushError(errors, `Projection ${statement.id} collection_views for '${screenId}' must use 'sort <field> <asc|desc>'`, entry.loc);
-      } else {
-        if (!["asc", "desc"].includes(extra)) {
-          pushError(errors, `Projection ${statement.id} collection_views for '${screenId}' has invalid sort direction '${extra}'`, entry.loc);
-        }
-        if (outputFields.size > 0 && !outputFields.has(value)) {
-          pushError(errors, `Projection ${statement.id} collection_views references unknown output field '${value}' for sort on '${screenId}'`, entry.loc);
-        }
-      }
-    }
-
-    if (operation === "group") {
-      if (!value) {
-        pushError(errors, `Projection ${statement.id} collection_views for '${screenId}' must include a field for 'group'`, entry.loc);
-      } else if (outputFields.size > 0 && !outputFields.has(value)) {
-        pushError(errors, `Projection ${statement.id} collection_views references unknown output field '${value}' for group on '${screenId}'`, entry.loc);
-      }
-    }
-
-    if (operation === "view" && !UI_COLLECTION_PRESENTATIONS.has(value || "")) {
-      pushError(errors, `Projection ${statement.id} collection_views for '${screenId}' has invalid view '${value}'`, entry.loc);
-    }
-
-    if (operation === "refresh" && !["manual", "pull_to_refresh", "auto"].includes(value || "")) {
-      pushError(errors, `Projection ${statement.id} collection_views for '${screenId}' has invalid refresh '${value}'`, entry.loc);
-    }
-  }
-}
-
-function validateProjectionUiActions(errors, statement, fieldMap, registry) {
-  if (statement.kind !== "projection") {
-    return;
-  }
-
-  const actionsField = fieldMap.get("screen_actions")?.[0];
-  if (!actionsField || actionsField.value.type !== "block") {
-    return;
-  }
-
-  const screens = collectProjectionUiScreens(statement, fieldMap);
-  const realized = new Set(symbolValues(getFieldValue(statement, "realizes")));
-
-  for (const entry of actionsField.value.entries) {
-    const tokens = blockSymbolItems(entry).map((item) => item.value);
-    const [keyword, screenId, actionKeyword, capabilityId, prominenceKeyword, prominence, placementKeyword, placement] = tokens;
-
-    if (keyword !== "screen") {
-      pushError(errors, `Projection ${statement.id} screen_actions entries must start with 'screen'`, entry.loc);
-      continue;
-    }
-    if (!screens.has(screenId)) {
-      pushError(errors, `Projection ${statement.id} screen_actions references unknown screen '${screenId}'`, entry.loc);
-    }
-    if (actionKeyword !== "action") {
-      pushError(errors, `Projection ${statement.id} screen_actions for '${screenId}' must use 'action'`, entry.loc);
-    }
-    const capability = registry.get(capabilityId);
-    if (!capability) {
-      pushError(errors, `Projection ${statement.id} screen_actions references missing capability '${capabilityId}'`, entry.loc);
-    } else if (capability.kind !== "capability") {
-      pushError(errors, `Projection ${statement.id} screen_actions must reference a capability, found ${capability.kind} '${capability.id}'`, entry.loc);
-    } else if (!realized.has(capabilityId)) {
-      pushError(errors, `Projection ${statement.id} screen_actions for '${screenId}' capability '${capabilityId}' must also appear in 'realizes'`, entry.loc);
-    }
-    if (prominenceKeyword !== "prominence") {
-      pushError(errors, `Projection ${statement.id} screen_actions for '${screenId}' must use 'prominence'`, entry.loc);
-    }
-    if (!["primary", "secondary", "destructive", "contextual"].includes(prominence || "")) {
-      pushError(errors, `Projection ${statement.id} screen_actions for '${screenId}' has invalid prominence '${prominence}'`, entry.loc);
-    }
-    if (placementKeyword && placementKeyword !== "placement") {
-      pushError(errors, `Projection ${statement.id} screen_actions for '${screenId}' has unknown directive '${placementKeyword}'`, entry.loc);
-    }
-    if (placementKeyword === "placement" && !["toolbar", "menu", "bulk", "inline", "footer"].includes(placement || "")) {
-      pushError(errors, `Projection ${statement.id} screen_actions for '${screenId}' has invalid placement '${placement}'`, entry.loc);
-    }
-  }
-}
-
-function validateProjectionUiAppShell(errors, statement, fieldMap) {
-  if (statement.kind !== "projection") {
-    return;
-  }
-
-  const shellField = fieldMap.get("app_shell")?.[0];
-  if (!shellField || shellField.value.type !== "block") {
-    return;
-  }
-
-  const seenKeys = new Set();
-  for (const entry of shellField.value.entries) {
-    const tokens = blockSymbolItems(entry).map((item) => item.value);
-    const [key, value, extra] = tokens;
-    if (!["brand", "shell", "primary_nav", "secondary_nav", "utility_nav", "footer", "global_search", "notifications", "account_menu", "workspace_switcher", "windowing"].includes(key || "")) {
-      pushError(errors, `Projection ${statement.id} app_shell has unknown key '${key}'`, entry.loc);
-      continue;
-    }
-    if (!value) {
-      pushError(errors, `Projection ${statement.id} app_shell is missing a value for '${key}'`, entry.loc);
-      continue;
-    }
-    if (extra) {
-      pushError(errors, `Projection ${statement.id} app_shell '${key}' accepts exactly one value`, entry.loc);
-    }
-    if (seenKeys.has(key)) {
-      pushError(errors, `Projection ${statement.id} app_shell has duplicate key '${key}'`, entry.loc);
-    }
-    seenKeys.add(key);
-
-    if (key === "shell" && !UI_APP_SHELL_KINDS.has(value)) {
-      pushError(errors, `Projection ${statement.id} app_shell has invalid shell '${value}'`, entry.loc);
-    }
-    if (["global_search", "notifications", "account_menu", "workspace_switcher"].includes(key) && !["true", "false"].includes(value)) {
-      pushError(errors, `Projection ${statement.id} app_shell '${key}' must be true or false`, entry.loc);
-    }
-    if (key === "windowing" && !UI_WINDOWING_MODES.has(value)) {
-      pushError(errors, `Projection ${statement.id} app_shell has invalid windowing '${value}'`, entry.loc);
-    }
-  }
-}
-
-const SHARED_UI_SEMANTIC_BLOCKS = [
-  "screens",
-  "collection_views",
-  "screen_actions",
-  "visibility_rules",
-  "field_lookups",
-  "app_shell",
-  "navigation",
-  "screen_regions"
-];
-
-function validateProjectionUiOwnership(errors, statement, fieldMap) {
-  if (statement.kind !== "projection") {
-    return;
-  }
-
-  const projectionType = symbolValue(getFieldValue(statement, "type"));
-  for (const key of SHARED_UI_SEMANTIC_BLOCKS) {
-    const field = fieldMap.get(key)?.[0];
-    if (!field || field.value.type !== "block") {
-      continue;
-    }
-    if (projectionType !== "ui_contract") {
-      pushError(
-        errors,
-        `Projection ${statement.id} ${key} belongs on shared UI projections; concrete UI projections may define screen_routes and surface hints only`,
-        field.loc
-      );
-    }
-  }
-
-  const routesField = fieldMap.get("screen_routes")?.[0];
-  if (routesField?.value.type === "block" && !["web_surface", "ios_surface"].includes(projectionType || "")) {
-    pushError(
-      errors,
-      `Projection ${statement.id} screen_routes belongs on concrete UI projections; shared UI projections own semantic screens and regions`,
-      routesField.loc
-    );
-  }
-}
-
-function validateProjectionUiDesign(errors, statement, fieldMap) {
-  if (statement.kind !== "projection") {
-    return;
-  }
-
-  const designField = fieldMap.get("design_tokens")?.[0];
-  if (!designField || designField.value.type !== "block") {
-    return;
-  }
-
-  if (symbolValue(getFieldValue(statement, "type")) !== "ui_contract") {
-    pushError(errors, `Projection ${statement.id} design_tokens belongs on shared UI projections; concrete UI projections inherit semantic design intent through 'realizes'`, designField.loc);
-  }
-
-  for (const entry of designField.value.entries) {
-    const tokens = blockSymbolItems(entry).map((item) => item.value);
-    const [key, value, extra] = tokens;
-
-    if (key === "density") {
-      if (!UI_DESIGN_DENSITIES.has(value || "")) {
-        pushError(errors, `Projection ${statement.id} design_tokens density has invalid value '${value}'`, entry.loc);
-      }
-      if (tokens.length !== 2) {
-        pushError(errors, `Projection ${statement.id} design_tokens density accepts exactly one value`, entry.loc);
-      }
-      continue;
-    }
-
-    if (key === "tone") {
-      if (!UI_DESIGN_TONES.has(value || "")) {
-        pushError(errors, `Projection ${statement.id} design_tokens tone has invalid value '${value}'`, entry.loc);
-      }
-      if (tokens.length !== 2) {
-        pushError(errors, `Projection ${statement.id} design_tokens tone accepts exactly one value`, entry.loc);
-      }
-      continue;
-    }
-
-    if (key === "radius_scale") {
-      if (!UI_DESIGN_RADIUS_SCALES.has(value || "")) {
-        pushError(errors, `Projection ${statement.id} design_tokens radius_scale has invalid value '${value}'`, entry.loc);
-      }
-      if (tokens.length !== 2) {
-        pushError(errors, `Projection ${statement.id} design_tokens radius_scale accepts exactly one value`, entry.loc);
-      }
-      continue;
-    }
-
-    if (key === "color_role") {
-      if (!UI_DESIGN_COLOR_ROLES.has(value || "")) {
-        pushError(errors, `Projection ${statement.id} design_tokens color_role has invalid role '${value}'`, entry.loc);
-      }
-      if (tokens.length !== 3) {
-        pushError(errors, `Projection ${statement.id} design_tokens color_role must use 'color_role <role> <semantic-token>'`, entry.loc);
-      }
-      continue;
-    }
-
-    if (key === "typography_role") {
-      if (!UI_DESIGN_TYPOGRAPHY_ROLES.has(value || "")) {
-        pushError(errors, `Projection ${statement.id} design_tokens typography_role has invalid role '${value}'`, entry.loc);
-      }
-      if (tokens.length !== 3) {
-        pushError(errors, `Projection ${statement.id} design_tokens typography_role must use 'typography_role <role> <semantic-token>'`, entry.loc);
-      }
-      continue;
-    }
-
-    if (key === "action_role") {
-      if (!UI_DESIGN_ACTION_ROLES.has(value || "")) {
-        pushError(errors, `Projection ${statement.id} design_tokens action_role has invalid role '${value}'`, entry.loc);
-      }
-      if (tokens.length !== 3) {
-        pushError(errors, `Projection ${statement.id} design_tokens action_role must use 'action_role <role> <semantic-token>'`, entry.loc);
-      }
-      continue;
-    }
-
-    if (key === "accessibility") {
-      const values = UI_DESIGN_ACCESSIBILITY_VALUES[value];
-      if (tokens.length !== 3) {
-        pushError(errors, `Projection ${statement.id} design_tokens accessibility must use 'accessibility <setting> <value>'`, entry.loc);
-      }
-      if (!values) {
-        pushError(errors, `Projection ${statement.id} design_tokens accessibility has invalid setting '${value}'`, entry.loc);
-      } else if (!values.has(extra || "")) {
-        pushError(errors, `Projection ${statement.id} design_tokens accessibility '${value}' has invalid value '${extra}'`, entry.loc);
-      }
-      continue;
-    }
-
-    pushError(errors, `Projection ${statement.id} design_tokens has unknown key '${key}'`, entry.loc);
-  }
-}
-
-function validateProjectionUiNavigation(errors, statement, fieldMap, registry) {
-  if (statement.kind !== "projection") {
-    return;
-  }
-
-  const navigationField = fieldMap.get("navigation")?.[0];
-  if (!navigationField || navigationField.value.type !== "block") {
-    return;
-  }
-
-  const availableScreens = collectAvailableUiScreenIds(statement, fieldMap, registry);
-  const groups = new Set();
-
-  for (const entry of navigationField.value.entries) {
-    const tokens = blockSymbolItems(entry).map((item) => item.value);
-    const [targetKind, targetId] = tokens;
-
-    if (targetKind === "group") {
-      if (!targetId || !IDENTIFIER_PATTERN.test(targetId)) {
-        pushError(errors, `Projection ${statement.id} navigation group entries must include a valid group id`, entry.loc);
-        continue;
-      }
-      groups.add(targetId);
-      const directives = parseUiDirectiveMap(tokens, 2, errors, statement, entry, `navigation group '${targetId}'`);
-      for (const key of directives.keys()) {
-        if (!["label", "placement", "icon", "order", "pattern"].includes(key)) {
-          pushError(errors, `Projection ${statement.id} navigation group '${targetId}' has unknown directive '${key}'`, entry.loc);
-        }
-      }
-      if (directives.has("placement") && !["primary", "secondary", "utility"].includes(directives.get("placement"))) {
-        pushError(errors, `Projection ${statement.id} navigation group '${targetId}' has invalid placement '${directives.get("placement")}'`, entry.loc);
-      }
-      if (directives.has("pattern") && !UI_NAVIGATION_PATTERNS.has(directives.get("pattern"))) {
-        pushError(errors, `Projection ${statement.id} navigation group '${targetId}' has invalid pattern '${directives.get("pattern")}'`, entry.loc);
-      }
-      continue;
-    }
-
-    if (targetKind === "screen") {
-      if (!availableScreens.has(targetId)) {
-        pushError(errors, `Projection ${statement.id} navigation references unknown screen '${targetId}'`, entry.loc);
-      }
-      const directives = parseUiDirectiveMap(tokens, 2, errors, statement, entry, `navigation screen '${targetId}'`);
-      for (const key of directives.keys()) {
-        if (!["group", "label", "order", "visible", "default", "breadcrumb", "sitemap", "placement", "pattern"].includes(key)) {
-          pushError(errors, `Projection ${statement.id} navigation screen '${targetId}' has unknown directive '${key}'`, entry.loc);
-        }
-      }
-      if (directives.has("visible") && !["true", "false"].includes(directives.get("visible"))) {
-        pushError(errors, `Projection ${statement.id} navigation screen '${targetId}' has invalid visible '${directives.get("visible")}'`, entry.loc);
-      }
-      if (directives.has("default") && !["true", "false"].includes(directives.get("default"))) {
-        pushError(errors, `Projection ${statement.id} navigation screen '${targetId}' has invalid default '${directives.get("default")}'`, entry.loc);
-      }
-      if (directives.has("placement") && !["primary", "secondary", "utility"].includes(directives.get("placement"))) {
-        pushError(errors, `Projection ${statement.id} navigation screen '${targetId}' has invalid placement '${directives.get("placement")}'`, entry.loc);
-      }
-      if (directives.has("sitemap") && !["include", "exclude"].includes(directives.get("sitemap"))) {
-        pushError(errors, `Projection ${statement.id} navigation screen '${targetId}' has invalid sitemap '${directives.get("sitemap")}'`, entry.loc);
-      }
-      if (directives.has("pattern") && !UI_NAVIGATION_PATTERNS.has(directives.get("pattern"))) {
-        pushError(errors, `Projection ${statement.id} navigation screen '${targetId}' has invalid pattern '${directives.get("pattern")}'`, entry.loc);
-      }
-      const breadcrumb = directives.get("breadcrumb");
-      if (breadcrumb && breadcrumb !== "none" && !availableScreens.has(breadcrumb)) {
-        pushError(errors, `Projection ${statement.id} navigation screen '${targetId}' references unknown breadcrumb screen '${breadcrumb}'`, entry.loc);
-      }
-      continue;
-    }
-
-    pushError(errors, `Projection ${statement.id} navigation entries must start with 'group' or 'screen'`, entry.loc);
-  }
-
-  for (const entry of navigationField.value.entries) {
-    const tokens = blockSymbolItems(entry).map((item) => item.value);
-    if (tokens[0] !== "screen") {
-      continue;
-    }
-    const directives = parseUiDirectiveMap(tokens, 2, [], statement, entry, "");
-    if (directives.has("group") && !groups.has(directives.get("group"))) {
-      pushError(errors, `Projection ${statement.id} navigation screen '${tokens[1]}' references unknown group '${directives.get("group")}'`, entry.loc);
-    }
-  }
-}
-
-function validateProjectionUiScreenRegions(errors, statement, fieldMap, registry) {
-  if (statement.kind !== "projection") {
-    return;
-  }
-
-  const regionField = fieldMap.get("screen_regions")?.[0];
-  if (!regionField || regionField.value.type !== "block") {
-    return;
-  }
-
-  const availableScreens = collectAvailableUiScreenIds(statement, fieldMap, registry);
-  for (const entry of regionField.value.entries) {
-    const tokens = blockSymbolItems(entry).map((item) => item.value);
-    const [keyword, screenId, regionKeyword, regionName] = tokens;
-
-    if (keyword !== "screen") {
-      pushError(errors, `Projection ${statement.id} screen_regions entries must start with 'screen'`, entry.loc);
-      continue;
-    }
-    if (!availableScreens.has(screenId)) {
-      pushError(errors, `Projection ${statement.id} screen_regions references unknown screen '${screenId}'`, entry.loc);
-    }
-    if (regionKeyword !== "region") {
-      pushError(errors, `Projection ${statement.id} screen_regions for '${screenId}' must use 'region'`, entry.loc);
-    }
-    if (!UI_REGION_KINDS.has(regionName || "")) {
-      pushError(errors, `Projection ${statement.id} screen_regions for '${screenId}' has invalid region '${regionName}'`, entry.loc);
-    }
-
-    const directives = parseUiDirectiveMap(tokens, 4, errors, statement, entry, `screen_regions for '${screenId}'`);
-    for (const key of directives.keys()) {
-      if (!["pattern", "placement", "title", "state", "variant"].includes(key)) {
-        pushError(errors, `Projection ${statement.id} screen_regions for '${screenId}' has unknown directive '${key}'`, entry.loc);
-      }
-    }
-    if (directives.has("pattern") && !UI_PATTERN_KINDS.has(directives.get("pattern"))) {
-      pushError(errors, `Projection ${statement.id} screen_regions for '${screenId}' has invalid pattern '${directives.get("pattern")}'`, entry.loc);
-    }
-    if (directives.has("placement") && !["primary", "secondary", "supporting"].includes(directives.get("placement"))) {
-      pushError(errors, `Projection ${statement.id} screen_regions for '${screenId}' has invalid placement '${directives.get("placement")}'`, entry.loc);
-    }
-    if (directives.has("state") && !UI_STATE_KINDS.has(directives.get("state"))) {
-      pushError(errors, `Projection ${statement.id} screen_regions for '${screenId}' has invalid state '${directives.get("state")}'`, entry.loc);
-    }
-  }
-}
-
-function validateProjectionUiComponents(errors, statement, fieldMap, registry) {
-  if (statement.kind !== "projection") {
-    return;
-  }
-
-  const componentsField = fieldMap.get("widget_bindings")?.[0];
-  if (!componentsField || componentsField.value.type !== "block") {
-    return;
-  }
-
-  if (symbolValue(getFieldValue(statement, "type")) !== "ui_contract") {
-    pushError(errors, `Projection ${statement.id} widget_bindings belongs on shared UI projections; concrete UI projections inherit widget placement through 'realizes'`, componentsField.loc);
-  }
-
-  const availableScreens = collectAvailableUiScreenIds(statement, fieldMap, registry);
-  const availableRegions = collectAvailableUiRegionKeys(statement, registry);
-  const availableRegionPatterns = collectAvailableUiRegionPatterns(statement, registry);
-
-  for (const entry of componentsField.value.entries) {
-    const tokens = blockSymbolItems(entry).map((item) => item.value);
-    const [screenKeyword, screenId, regionKeyword, regionName, componentKeyword, componentId] = tokens;
-
-    if (screenKeyword !== "screen") {
-      pushError(errors, `Projection ${statement.id} widget_bindings entries must start with 'screen'`, entry.loc);
-      continue;
-    }
-    if (!availableScreens.has(screenId)) {
-      pushError(errors, `Projection ${statement.id} widget_bindings references unknown screen '${screenId}'`, entry.loc);
-    }
-    if (regionKeyword !== "region") {
-      pushError(errors, `Projection ${statement.id} widget_bindings for '${screenId}' must use 'region'`, entry.loc);
-    }
-    if (!UI_REGION_KINDS.has(regionName || "")) {
-      pushError(errors, `Projection ${statement.id} widget_bindings for '${screenId}' has invalid region '${regionName}'`, entry.loc);
-    } else if (!availableRegions.has(`${screenId}:${regionName}`)) {
-      pushError(errors, `Projection ${statement.id} widget_bindings for '${screenId}' references undeclared region '${regionName}'`, entry.loc);
-    }
-    if (componentKeyword !== "widget") {
-      pushError(errors, `Projection ${statement.id} widget_bindings for '${screenId}' must use 'widget'`, entry.loc);
-    }
-
-    const widget = registry.get(componentId);
-    if (!widget) {
-      pushError(errors, `Projection ${statement.id} widget_bindings references missing widget '${componentId}'`, entry.loc);
-      continue;
-    }
-    if (widget.kind !== "widget") {
-      pushError(errors, `Projection ${statement.id} widget_bindings must reference a widget, found ${widget.kind} '${widget.id}'`, entry.loc);
-      continue;
-    }
-
-    const propNames = new Set(blockEntries(getFieldValue(widget, "props"))
-      .map((propEntry) => propEntry.items[0])
-      .filter((item) => item?.type === "symbol")
-      .map((item) => item.value));
-    const eventNames = new Set(blockEntries(getFieldValue(widget, "events"))
-      .map((eventEntry) => eventEntry.items[0])
-      .filter((item) => item?.type === "symbol")
-      .map((item) => item.value));
-    const componentRegions = symbolValues(getFieldValue(widget, "regions"));
-    const componentPatterns = symbolValues(getFieldValue(widget, "patterns"));
-    if (componentRegions.length > 0 && !componentRegions.includes(regionName)) {
-      pushError(
-        errors,
-        `Projection ${statement.id} widget_bindings uses widget '${componentId}' in region '${regionName}', but the widget supports regions [${componentRegions.join(", ")}]`,
-        entry.loc
-      );
-    }
-    const regionPattern = availableRegionPatterns.get(`${screenId}:${regionName}`) || null;
-    if (regionPattern && componentPatterns.length > 0 && !componentPatterns.includes(regionPattern)) {
-      pushError(
-        errors,
-        `Projection ${statement.id} widget_bindings uses widget '${componentId}' in '${screenId}:${regionName}' with pattern '${regionPattern}', but the widget supports patterns [${componentPatterns.join(", ")}]`,
-        entry.loc
-      );
-    }
-
-    for (let i = 6; i < tokens.length;) {
-      const directive = tokens[i];
-      if (directive === "data") {
-        const propName = tokens[i + 1];
-        const fromKeyword = tokens[i + 2];
-        const sourceId = tokens[i + 3];
-        if (!propName || fromKeyword !== "from" || !sourceId) {
-          pushError(errors, `Projection ${statement.id} widget_bindings data bindings must use 'data <prop> from <source>'`, entry.loc);
-          break;
-        }
-        if (!propNames.has(propName)) {
-          pushError(errors, `Projection ${statement.id} widget_bindings references unknown prop '${propName}' on widget '${componentId}'`, entry.loc);
-        }
-        const source = registry.get(sourceId);
-        if (!source || !["capability", "projection", "shape", "entity"].includes(source.kind)) {
-          pushError(errors, `Projection ${statement.id} widget_bindings data binding for '${propName}' references missing source '${sourceId}'`, entry.loc);
-        }
-        i += 4;
-        continue;
-      }
-
-      if (directive === "event") {
-        const eventName = tokens[i + 1];
-        const action = tokens[i + 2];
-        const targetId = tokens[i + 3];
-        if (!eventName || !action || !targetId) {
-          pushError(errors, `Projection ${statement.id} widget_bindings event bindings must use 'event <event> <navigate|action> <target>'`, entry.loc);
-          break;
-        }
-        if (!eventNames.has(eventName)) {
-          pushError(errors, `Projection ${statement.id} widget_bindings references unknown event '${eventName}' on widget '${componentId}'`, entry.loc);
-        }
-        if (action === "navigate") {
-          if (!availableScreens.has(targetId)) {
-            pushError(errors, `Projection ${statement.id} widget_bindings event '${eventName}' references unknown navigation target '${targetId}'`, entry.loc);
-          }
-        } else if (action === "action") {
-          const target = registry.get(targetId);
-          if (!target || target.kind !== "capability") {
-            pushError(errors, `Projection ${statement.id} widget_bindings event '${eventName}' references missing capability action '${targetId}'`, entry.loc);
-          }
-        } else {
-          pushError(errors, `Projection ${statement.id} widget_bindings event '${eventName}' has unsupported action '${action}'`, entry.loc);
-        }
-        i += 4;
-        continue;
-      }
-
-      pushError(errors, `Projection ${statement.id} widget_bindings has unknown directive '${directive}'`, entry.loc);
-      break;
-    }
-  }
-}
-
-function validateProjectionUiVisibility(errors, statement, fieldMap, registry) {
-  if (statement.kind !== "projection") {
-    return;
-  }
-
-  const visibilityField = fieldMap.get("visibility_rules")?.[0];
-  if (!visibilityField || visibilityField.value.type !== "block") {
-    return;
-  }
-
-  const realized = new Set(symbolValues(getFieldValue(statement, "realizes")));
-  for (const entry of visibilityField.value.entries) {
-    const tokens = blockSymbolItems(entry).map((item) => item.value);
-    const [keyword, capabilityId, predicateKeyword, predicateType, predicateValue] = tokens;
-
-    if (keyword !== "action") {
-      pushError(errors, `Projection ${statement.id} visibility_rules entries must start with 'action'`, entry.loc);
-      continue;
-    }
-
-    const capability = registry.get(capabilityId);
-    if (!capability) {
-      pushError(errors, `Projection ${statement.id} visibility_rules references missing capability '${capabilityId}'`, entry.loc);
-    } else if (capability.kind !== "capability") {
-      pushError(errors, `Projection ${statement.id} visibility_rules must reference a capability, found ${capability.kind} '${capability.id}'`, entry.loc);
-    } else if (!realized.has(capabilityId)) {
-      pushError(errors, `Projection ${statement.id} visibility_rules action '${capabilityId}' must also appear in 'realizes'`, entry.loc);
-    }
-
-    if (predicateKeyword !== "visible_if") {
-      pushError(errors, `Projection ${statement.id} visibility_rules for '${capabilityId}' must use 'visible_if'`, entry.loc);
-    }
-    if (!["permission", "ownership", "claim"].includes(predicateType || "")) {
-      pushError(errors, `Projection ${statement.id} visibility_rules for '${capabilityId}' has invalid predicate '${predicateType}'`, entry.loc);
-    }
-    if (!predicateValue) {
-      pushError(errors, `Projection ${statement.id} visibility_rules for '${capabilityId}' must include a predicate value`, entry.loc);
-    }
-    if (predicateType === "ownership" && !["owner", "owner_or_admin", "project_member", "none"].includes(predicateValue || "")) {
-      pushError(errors, `Projection ${statement.id} visibility_rules for '${capabilityId}' has invalid ownership '${predicateValue}'`, entry.loc);
-    }
-    const directiveTokens = blockSymbolItems(entry).map((item) => item.value);
-    const directives = new Map();
-    for (let i = 5; i < directiveTokens.length; i += 2) {
-      const key = directiveTokens[i];
-      const value = directiveTokens[i + 1];
-      if (!value) {
-        pushError(errors, `Projection ${statement.id} visibility_rules for '${capabilityId}' is missing a value for '${key}'`, entry.loc);
-        continue;
-      }
-      directives.set(key, value);
-    }
-    for (const key of directives.keys()) {
-      if (!["claim_value"].includes(key)) {
-        pushError(errors, `Projection ${statement.id} visibility_rules for '${capabilityId}' has unknown directive '${key}'`, entry.loc);
-      }
-    }
-    if (directives.get("claim_value") && predicateType !== "claim") {
-      pushError(errors, `Projection ${statement.id} visibility_rules for '${capabilityId}' cannot declare claim_value without claim`, entry.loc);
-    }
-  }
-}
-
-function validateProjectionUiLookups(errors, statement, fieldMap, registry) {
-  if (statement.kind !== "projection") {
-    return;
-  }
-
-  const lookupsField = fieldMap.get("field_lookups")?.[0];
-  if (!lookupsField || lookupsField.value.type !== "block") {
-    return;
-  }
-
-  const screens = collectProjectionUiScreens(statement, fieldMap);
-
-  for (const entry of lookupsField.value.entries) {
-    const tokens = blockSymbolItems(entry).map((item) => item.value);
-    const [keyword, screenId, fieldKeyword, fieldName, entityKeyword, entityId, labelKeyword, labelField, maybeEmptyKeyword, maybeEmptyLabel] = tokens;
-
-    if (keyword !== "screen") {
-      pushError(errors, `Projection ${statement.id} field_lookups entries must start with 'screen'`, entry.loc);
-      continue;
-    }
-
-    const screenEntry = screens.get(screenId);
-    if (!screenEntry) {
-      pushError(errors, `Projection ${statement.id} field_lookups references unknown screen '${screenId}'`, entry.loc);
-      continue;
-    }
-
-    if (fieldKeyword !== "field") {
-      pushError(errors, `Projection ${statement.id} field_lookups for '${screenId}' must use 'field'`, entry.loc);
-    }
-    if (!fieldName) {
-      pushError(errors, `Projection ${statement.id} field_lookups for '${screenId}' must include a field name`, entry.loc);
-    }
-
-    if (entityKeyword !== "entity") {
-      pushError(errors, `Projection ${statement.id} field_lookups for '${screenId}' must use 'entity'`, entry.loc);
-    }
-    const entity = entityId ? registry.get(entityId) : null;
-    if (!entity) {
-      pushError(errors, `Projection ${statement.id} field_lookups for '${screenId}' references missing entity '${entityId}'`, entry.loc);
-    } else if (entity.kind !== "entity") {
-      pushError(errors, `Projection ${statement.id} field_lookups for '${screenId}' must reference an entity, found ${entity.kind} '${entity.id}'`, entry.loc);
-    }
-
-    if (labelKeyword !== "label_field") {
-      pushError(errors, `Projection ${statement.id} field_lookups for '${screenId}' must use 'label_field'`, entry.loc);
-    }
-    if (!labelField) {
-      pushError(errors, `Projection ${statement.id} field_lookups for '${screenId}' must include a label_field`, entry.loc);
-    }
-
-    if (maybeEmptyKeyword && maybeEmptyKeyword !== "empty_label") {
-      pushError(errors, `Projection ${statement.id} field_lookups for '${screenId}' has unknown directive '${maybeEmptyKeyword}'`, entry.loc);
-    }
-    if (maybeEmptyKeyword === "empty_label" && !maybeEmptyLabel) {
-      pushError(errors, `Projection ${statement.id} field_lookups for '${screenId}' must include a value for 'empty_label'`, entry.loc);
-    }
-
-    const availableFields = resolveProjectionUiScreenFieldNames(registry, screenEntry, statement);
-    if (fieldName && availableFields.size > 0 && !availableFields.has(fieldName)) {
-      pushError(errors, `Projection ${statement.id} field_lookups for '${screenId}' references unknown screen field '${fieldName}'`, entry.loc);
-    }
-
-    if (entity?.kind === "entity") {
-      const entityFieldNames = new Set(statementFieldNames(entity));
-      if (labelField && !entityFieldNames.has(labelField)) {
-        pushError(errors, `Projection ${statement.id} field_lookups for '${screenId}' references unknown entity field '${labelField}' on '${entity.id}'`, entry.loc);
-      }
-    }
-  }
-}
-
-function validateProjectionUiRoutes(errors, statement, fieldMap, registry) {
-  if (statement.kind !== "projection") {
-    return;
-  }
-
-  const routesField = fieldMap.get("screen_routes")?.[0];
-  if (!routesField || routesField.value.type !== "block") {
-    return;
-  }
-
-  const availableScreens = collectAvailableUiScreenIds(statement, fieldMap, registry);
-  const seenPaths = new Set();
-  const projectionType = symbolValue(getFieldValue(statement, "type"));
-
-  for (const entry of routesField.value.entries) {
-    const tokens = blockSymbolItems(entry).map((item) => item.value);
-    const [keyword, screenId, pathKeyword, routePath] = tokens;
-
-    if (keyword !== "screen") {
-      pushError(errors, `Projection ${statement.id} screen_routes entries must start with 'screen'`, entry.loc);
-      continue;
-    }
-    if (!availableScreens.has(screenId)) {
-      pushError(errors, `Projection ${statement.id} screen_routes references unknown screen '${screenId}'`, entry.loc);
-    }
-    if (pathKeyword !== "path") {
-      pushError(errors, `Projection ${statement.id} screen_routes for '${screenId}' must use 'path'`, entry.loc);
-    }
-    if (!routePath) {
-      pushError(errors, `Projection ${statement.id} screen_routes for '${screenId}' must include a path`, entry.loc);
-      continue;
-    }
-    if ((projectionType === "web_surface" || projectionType === "ios_surface") && !routePath.startsWith("/")) {
-      pushError(errors, `Projection ${statement.id} screen_routes for '${screenId}' must use an absolute path`, entry.loc);
-    }
-    if (seenPaths.has(routePath)) {
-      pushError(errors, `Projection ${statement.id} screen_routes has duplicate path '${routePath}'`, entry.loc);
-    }
-    seenPaths.add(routePath);
-  }
-}
-
-function validateProjectionUiSurfaceHints(errors, statement, fieldMap, registry, surfaceBlockKey, expectedProjectionType) {
-  if (statement.kind !== "projection") {
-    return;
-  }
-
-  const surfaceField = fieldMap.get(surfaceBlockKey)?.[0];
-  if (!surfaceField || surfaceField.value.type !== "block") {
-    return;
-  }
-
-  const projectionType = symbolValue(getFieldValue(statement, "type"));
-  if (projectionType !== expectedProjectionType) {
-    pushError(errors, `Projection ${statement.id} may only use '${surfaceBlockKey}' when projection type is '${expectedProjectionType}'`, surfaceField.loc);
-    return;
-  }
-
-  const availableScreens = collectAvailableUiScreenIds(statement, fieldMap, registry);
-  const realized = new Set(symbolValues(getFieldValue(statement, "realizes")));
-  for (const entry of surfaceField.value.entries) {
-    const tokens = blockSymbolItems(entry).map((item) => item.value);
-    const [targetKind, targetId, directive, value] = tokens;
-
-    if (targetKind === "screen") {
-      if (!availableScreens.has(targetId)) {
-        pushError(errors, `Projection ${statement.id} ${surfaceBlockKey} references unknown screen '${targetId}'`, entry.loc);
-      }
-      if (!["layout", "desktop_variant", "mobile_variant", "present", "shell", "collection", "breadcrumbs", "state_style"].includes(directive || "")) {
-        pushError(errors, `Projection ${statement.id} ${surfaceBlockKey} for screen '${targetId}' has unknown directive '${directive}'`, entry.loc);
-      }
-      if (directive === "desktop_variant" && !UI_COLLECTION_PRESENTATIONS.has(value || "")) {
-        pushError(errors, `Projection ${statement.id} ${surfaceBlockKey} for screen '${targetId}' has invalid desktop_variant '${value}'`, entry.loc);
-      }
-      if (directive === "mobile_variant" && !UI_COLLECTION_PRESENTATIONS.has(value || "")) {
-        pushError(errors, `Projection ${statement.id} ${surfaceBlockKey} for screen '${targetId}' has invalid mobile_variant '${value}'`, entry.loc);
-      }
-      if (directive === "collection" && !UI_COLLECTION_PRESENTATIONS.has(value || "")) {
-        pushError(errors, `Projection ${statement.id} ${surfaceBlockKey} for screen '${targetId}' has invalid collection '${value}'`, entry.loc);
-      }
-      if (directive === "shell" && !["topbar", "sidebar", "dual_nav", "workspace", "wizard", "bottom_tabs", "split_view", "menu_bar"].includes(value || "")) {
-        pushError(errors, `Projection ${statement.id} ${surfaceBlockKey} for screen '${targetId}' has invalid shell '${value}'`, entry.loc);
-      }
-      if (directive === "present" && !["page", "modal", "drawer", "sheet", "bottom_sheet", "popover"].includes(value || "")) {
-        pushError(errors, `Projection ${statement.id} ${surfaceBlockKey} for screen '${targetId}' has invalid present '${value}'`, entry.loc);
-      }
-      if (directive === "breadcrumbs" && !["visible", "hidden"].includes(value || "")) {
-        pushError(errors, `Projection ${statement.id} ${surfaceBlockKey} for screen '${targetId}' has invalid breadcrumbs '${value}'`, entry.loc);
-      }
-      if (directive === "state_style" && !["inline", "panel", "full_page"].includes(value || "")) {
-        pushError(errors, `Projection ${statement.id} ${surfaceBlockKey} for screen '${targetId}' has invalid state_style '${value}'`, entry.loc);
-      }
-      continue;
-    }
-
-    if (targetKind === "action") {
-      const capability = registry.get(targetId);
-      if (!capability) {
-        pushError(errors, `Projection ${statement.id} ${surfaceBlockKey} references missing capability '${targetId}'`, entry.loc);
-      } else if (capability.kind !== "capability") {
-        pushError(errors, `Projection ${statement.id} ${surfaceBlockKey} must reference a capability for action '${targetId}', found ${capability.kind} '${capability.id}'`, entry.loc);
-      } else if (!realized.has(targetId)) {
-        pushError(errors, `Projection ${statement.id} ${surfaceBlockKey} action '${targetId}' must also appear in 'realizes'`, entry.loc);
-      }
-      if (!["confirm", "present", "placement"].includes(directive || "")) {
-        pushError(errors, `Projection ${statement.id} ${surfaceBlockKey} for action '${targetId}' has unknown directive '${directive}'`, entry.loc);
-      }
-      if (directive === "confirm" && !["modal", "inline", "sheet", "bottom_sheet", "popover"].includes(value || "")) {
-        pushError(errors, `Projection ${statement.id} ${surfaceBlockKey} for action '${targetId}' has invalid confirm mode '${value}'`, entry.loc);
-      }
-      if (directive === "present" && !["button", "menu_item", "split_button", "bulk_action", "drawer", "sheet", "bottom_sheet", "fab", "popover"].includes(value || "")) {
-        pushError(errors, `Projection ${statement.id} ${surfaceBlockKey} for action '${targetId}' has invalid present mode '${value}'`, entry.loc);
-      }
-      if (directive === "placement" && !["toolbar", "menu", "bulk", "inline", "footer"].includes(value || "")) {
-        pushError(errors, `Projection ${statement.id} ${surfaceBlockKey} for action '${targetId}' has invalid placement '${value}'`, entry.loc);
-      }
-      continue;
-    }
-
-    pushError(errors, `Projection ${statement.id} ${surfaceBlockKey} entries must start with 'screen' or 'action'`, entry.loc);
-  }
-}
-
-function validateProjectionUiWeb(errors, statement, fieldMap, registry) {
-  validateProjectionUiSurfaceHints(errors, statement, fieldMap, registry, "web_hints", "web_surface");
-}
-
-function validateProjectionUiIos(errors, statement, fieldMap, registry) {
-  validateProjectionUiSurfaceHints(errors, statement, fieldMap, registry, "ios_hints", "ios_surface");
-}
-
-function validateProjectionGeneratorDefaults(errors, statement, fieldMap) {
-  if (statement.kind !== "projection") {
-    return;
-  }
-
-  const generatorField = fieldMap.get("generator_defaults")?.[0];
-  if (!generatorField || generatorField.value.type !== "block") {
-    return;
-  }
-
-  for (const entry of generatorField.value.entries) {
-    const tokens = blockSymbolItems(entry).map((item) => item.value);
-    const [key, value] = tokens;
-    if (!["profile", "language", "styling"].includes(key || "")) {
-      pushError(errors, `Projection ${statement.id} generator_defaults has unknown key '${key}'`, entry.loc);
-      continue;
-    }
-    if (!value) {
-      pushError(errors, `Projection ${statement.id} generator_defaults is missing a value for '${key}'`, entry.loc);
-      continue;
-    }
-    if (key === "profile" && !["vanilla", "sveltekit", "react", "swiftui", "postgres_sql", "sqlite_sql", "prisma", "drizzle"].includes(value)) {
-      pushError(errors, `Projection ${statement.id} generator_defaults has unsupported profile '${value}'`, entry.loc);
-    }
-    if (key === "language" && !["typescript", "javascript", "swift", "sql"].includes(value)) {
-      pushError(errors, `Projection ${statement.id} generator_defaults has unsupported language '${value}'`, entry.loc);
-    }
-    if (key === "styling" && !["tailwind", "css"].includes(value)) {
-      pushError(errors, `Projection ${statement.id} generator_defaults has unsupported styling '${value}'`, entry.loc);
-    }
-  }
-}
-
-function validateProjectionDbTables(errors, statement, fieldMap, registry) {
-  if (statement.kind !== "projection") {
-    return;
-  }
-
-  const dbTablesField = fieldMap.get("tables")?.[0];
-  if (!dbTablesField || dbTablesField.value.type !== "block") {
-    return;
-  }
-
-  const realized = new Set(symbolValues(getFieldValue(statement, "realizes")));
-  const seenTables = new Set();
-  for (const entry of dbTablesField.value.entries) {
-    const tokens = blockSymbolItems(entry).map((item) => item.value);
-    const [entityId, tableKeyword, tableName] = tokens;
-    const entity = registry.get(entityId);
-
-    if (!entity) {
-      pushError(errors, `Projection ${statement.id} tables references missing entity '${entityId}'`, entry.loc);
-      continue;
-    }
-    if (entity.kind !== "entity") {
-      pushError(errors, `Projection ${statement.id} tables must target an entity, found ${entity.kind} '${entity.id}'`, entry.loc);
-    }
-    if (!realized.has(entityId)) {
-      pushError(errors, `Projection ${statement.id} tables entity '${entityId}' must also appear in 'realizes'`, entry.loc);
-    }
-    if (tableKeyword !== "table") {
-      pushError(errors, `Projection ${statement.id} tables for '${entityId}' must use 'table'`, entry.loc);
-    }
-    if (!tableName) {
-      pushError(errors, `Projection ${statement.id} tables for '${entityId}' must include a table name`, entry.loc);
-    } else if (seenTables.has(tableName)) {
-      pushError(errors, `Projection ${statement.id} tables has duplicate table name '${tableName}'`, entry.loc);
-    }
-    seenTables.add(tableName);
-  }
-}
-
-function validateProjectionDbColumns(errors, statement, fieldMap, registry) {
-  if (statement.kind !== "projection") {
-    return;
-  }
-
-  const dbColumnsField = fieldMap.get("columns")?.[0];
-  if (!dbColumnsField || dbColumnsField.value.type !== "block") {
-    return;
-  }
-
-  const realized = new Set(symbolValues(getFieldValue(statement, "realizes")));
-  for (const entry of dbColumnsField.value.entries) {
-    const tokens = blockSymbolItems(entry).map((item) => item.value);
-    const [entityId, fieldKeyword, fieldName, columnKeyword, columnName] = tokens;
-    const entity = registry.get(entityId);
-
-    if (!entity) {
-      pushError(errors, `Projection ${statement.id} columns references missing entity '${entityId}'`, entry.loc);
-      continue;
-    }
-    if (entity.kind !== "entity") {
-      pushError(errors, `Projection ${statement.id} columns must target an entity, found ${entity.kind} '${entity.id}'`, entry.loc);
-    }
-    if (!realized.has(entityId)) {
-      pushError(errors, `Projection ${statement.id} columns entity '${entityId}' must also appear in 'realizes'`, entry.loc);
-    }
-    if (fieldKeyword !== "field") {
-      pushError(errors, `Projection ${statement.id} columns for '${entityId}' must use 'field'`, entry.loc);
-    }
-    if (columnKeyword !== "column") {
-      pushError(errors, `Projection ${statement.id} columns for '${entityId}' must use 'column'`, entry.loc);
-    }
-    const entityFieldNames = new Set(statementFieldNames(entity));
-    if (fieldName && entityFieldNames.size > 0 && !entityFieldNames.has(fieldName)) {
-      pushError(errors, `Projection ${statement.id} columns references unknown field '${fieldName}' on ${entityId}`, entry.loc);
-    }
-    if (!columnName) {
-      pushError(errors, `Projection ${statement.id} columns for '${entityId}.${fieldName}' must include a column name`, entry.loc);
-    }
-  }
-}
-
-function validateProjectionDbKeys(errors, statement, fieldMap, registry) {
-  if (statement.kind !== "projection") {
-    return;
-  }
-
-  const dbKeysField = fieldMap.get("keys")?.[0];
-  if (!dbKeysField || dbKeysField.value.type !== "block") {
-    return;
-  }
-
-  const realized = new Set(symbolValues(getFieldValue(statement, "realizes")));
-  for (const entry of dbKeysField.value.entries) {
-    const tokens = blockSymbolItems(entry).map((item) => item.value);
-    const [entityId, keyType] = tokens;
-    const entity = registry.get(entityId);
-
-    if (!entity) {
-      pushError(errors, `Projection ${statement.id} keys references missing entity '${entityId}'`, entry.loc);
-      continue;
-    }
-    if (entity.kind !== "entity") {
-      pushError(errors, `Projection ${statement.id} keys must target an entity, found ${entity.kind} '${entity.id}'`, entry.loc);
-    }
-    if (!realized.has(entityId)) {
-      pushError(errors, `Projection ${statement.id} keys entity '${entityId}' must also appear in 'realizes'`, entry.loc);
-    }
-    if (!["primary", "unique"].includes(keyType || "")) {
-      pushError(errors, `Projection ${statement.id} keys for '${entityId}' has invalid key type '${keyType}'`, entry.loc);
-    }
-    const fieldList = entry.items[2];
-    if (!fieldList || fieldList.type !== "list" || fieldList.items.length === 0) {
-      pushError(errors, `Projection ${statement.id} keys for '${entityId}' must include a non-empty field list`, entry.loc);
-      continue;
-    }
-    const entityFieldNames = new Set(statementFieldNames(entity));
-    for (const item of fieldList.items) {
-      if (item.type === "symbol" && entityFieldNames.size > 0 && !entityFieldNames.has(item.value)) {
-        pushError(errors, `Projection ${statement.id} keys references unknown field '${item.value}' on ${entityId}`, item.loc);
-      }
-    }
-  }
-}
-
-function validateProjectionDbIndexes(errors, statement, fieldMap, registry) {
-  if (statement.kind !== "projection") {
-    return;
-  }
-
-  const dbIndexesField = fieldMap.get("indexes")?.[0];
-  if (!dbIndexesField || dbIndexesField.value.type !== "block") {
-    return;
-  }
-
-  const realized = new Set(symbolValues(getFieldValue(statement, "realizes")));
-  for (const entry of dbIndexesField.value.entries) {
-    const tokens = blockSymbolItems(entry).map((item) => item.value);
-    const [entityId, indexType] = tokens;
-    const entity = registry.get(entityId);
-
-    if (!entity) {
-      pushError(errors, `Projection ${statement.id} indexes references missing entity '${entityId}'`, entry.loc);
-      continue;
-    }
-    if (entity.kind !== "entity") {
-      pushError(errors, `Projection ${statement.id} indexes must target an entity, found ${entity.kind} '${entity.id}'`, entry.loc);
-    }
-    if (!realized.has(entityId)) {
-      pushError(errors, `Projection ${statement.id} indexes entity '${entityId}' must also appear in 'realizes'`, entry.loc);
-    }
-    if (!["index", "unique"].includes(indexType || "")) {
-      pushError(errors, `Projection ${statement.id} indexes for '${entityId}' has invalid index type '${indexType}'`, entry.loc);
-    }
-    const fieldList = entry.items[2];
-    if (!fieldList || fieldList.type !== "list" || fieldList.items.length === 0) {
-      pushError(errors, `Projection ${statement.id} indexes for '${entityId}' must include a non-empty field list`, entry.loc);
-      continue;
-    }
-    const entityFieldNames = new Set(statementFieldNames(entity));
-    for (const item of fieldList.items) {
-      if (item.type === "symbol" && entityFieldNames.size > 0 && !entityFieldNames.has(item.value)) {
-        pushError(errors, `Projection ${statement.id} indexes references unknown field '${item.value}' on ${entityId}`, item.loc);
-      }
-    }
-  }
-}
-
-function validateProjectionDbRelations(errors, statement, fieldMap, registry) {
-  if (statement.kind !== "projection") {
-    return;
-  }
-
-  const dbRelationsField = fieldMap.get("relations")?.[0];
-  if (!dbRelationsField || dbRelationsField.value.type !== "block") {
-    return;
-  }
-
-  const realized = new Set(symbolValues(getFieldValue(statement, "realizes")));
-  for (const entry of dbRelationsField.value.entries) {
-    const tokens = blockSymbolItems(entry).map((item) => item.value);
-    const [entityId, relationType, fieldName, referencesKeyword, targetRef, onDeleteKeyword, onDeleteValue] = tokens;
-    const entity = registry.get(entityId);
-
-    if (!entity) {
-      pushError(errors, `Projection ${statement.id} relations references missing entity '${entityId}'`, entry.loc);
-      continue;
-    }
-    if (entity.kind !== "entity") {
-      pushError(errors, `Projection ${statement.id} relations must target an entity, found ${entity.kind} '${entity.id}'`, entry.loc);
-    }
-    if (!realized.has(entityId)) {
-      pushError(errors, `Projection ${statement.id} relations entity '${entityId}' must also appear in 'realizes'`, entry.loc);
-    }
-    if (relationType !== "foreign_key") {
-      pushError(errors, `Projection ${statement.id} relations for '${entityId}' must use 'foreign_key'`, entry.loc);
-    }
-    if (referencesKeyword !== "references") {
-      pushError(errors, `Projection ${statement.id} relations for '${entityId}' must use 'references'`, entry.loc);
-    }
-    if (onDeleteKeyword && onDeleteKeyword !== "on_delete") {
-      pushError(errors, `Projection ${statement.id} relations for '${entityId}' has unexpected token '${onDeleteKeyword}'`, entry.loc);
-    }
-    if (onDeleteValue && !["cascade", "restrict", "set_null", "no_action"].includes(onDeleteValue)) {
-      pushError(errors, `Projection ${statement.id} relations for '${entityId}' has invalid on_delete '${onDeleteValue}'`, entry.loc);
-    }
-    const entityFieldNames = new Set(statementFieldNames(entity));
-    if (fieldName && entityFieldNames.size > 0 && !entityFieldNames.has(fieldName)) {
-      pushError(errors, `Projection ${statement.id} relations references unknown field '${fieldName}' on ${entityId}`, entry.loc);
-    }
-    const [targetEntityId, targetFieldName] = (targetRef || "").split(".");
-    const targetEntity = registry.get(targetEntityId);
-    if (!targetEntity) {
-      pushError(errors, `Projection ${statement.id} relations references missing target entity '${targetEntityId}'`, entry.loc);
-      continue;
-    }
-    if (targetEntity.kind !== "entity") {
-      pushError(errors, `Projection ${statement.id} relations must reference an entity target, found ${targetEntity.kind} '${targetEntity.id}'`, entry.loc);
-    }
-    const targetFieldNames = new Set(statementFieldNames(targetEntity));
-    if (targetFieldName && targetFieldNames.size > 0 && !targetFieldNames.has(targetFieldName)) {
-      pushError(errors, `Projection ${statement.id} relations references unknown target field '${targetFieldName}' on ${targetEntityId}`, entry.loc);
-    }
-  }
-}
-
-function validateProjectionDbLifecycle(errors, statement, fieldMap, registry) {
-  if (statement.kind !== "projection") {
-    return;
-  }
-
-  const dbLifecycleField = fieldMap.get("lifecycle")?.[0];
-  if (!dbLifecycleField || dbLifecycleField.value.type !== "block") {
-    return;
-  }
-
-  const realized = new Set(symbolValues(getFieldValue(statement, "realizes")));
-  for (const entry of dbLifecycleField.value.entries) {
-    const tokens = blockSymbolItems(entry).map((item) => item.value);
-    const [entityId, lifecycleType] = tokens;
-    const entity = registry.get(entityId);
-
-    if (!entity) {
-      pushError(errors, `Projection ${statement.id} lifecycle references missing entity '${entityId}'`, entry.loc);
-      continue;
-    }
-    if (entity.kind !== "entity") {
-      pushError(errors, `Projection ${statement.id} lifecycle must target an entity, found ${entity.kind} '${entity.id}'`, entry.loc);
-    }
-    if (!realized.has(entityId)) {
-      pushError(errors, `Projection ${statement.id} lifecycle entity '${entityId}' must also appear in 'realizes'`, entry.loc);
-    }
-
-    const directives = parseUiDirectiveMap(tokens, 2, errors, statement, entry, `lifecycle for '${entityId}'`);
-    if (!["soft_delete", "timestamps"].includes(lifecycleType || "")) {
-      pushError(errors, `Projection ${statement.id} lifecycle for '${entityId}' has invalid lifecycle '${lifecycleType}'`, entry.loc);
-      continue;
-    }
-
-    const entityFieldNames = new Set(statementFieldNames(entity));
-    if (lifecycleType === "soft_delete") {
-      for (const requiredKey of ["field", "value"]) {
-        if (!directives.has(requiredKey)) {
-          pushError(errors, `Projection ${statement.id} lifecycle for '${entityId}' must include '${requiredKey}' for soft_delete`, entry.loc);
-        }
-      }
-      const fieldName = directives.get("field");
-      if (fieldName && entityFieldNames.size > 0 && !entityFieldNames.has(fieldName)) {
-        pushError(errors, `Projection ${statement.id} lifecycle references unknown field '${fieldName}' on ${entityId}`, entry.loc);
-      }
-    }
-
-    if (lifecycleType === "timestamps") {
-      for (const requiredKey of ["created_at", "updated_at"]) {
-        if (!directives.has(requiredKey)) {
-          pushError(errors, `Projection ${statement.id} lifecycle for '${entityId}' must include '${requiredKey}' for timestamps`, entry.loc);
-        }
-        const fieldName = directives.get(requiredKey);
-        if (fieldName && entityFieldNames.size > 0 && !entityFieldNames.has(fieldName)) {
-          pushError(errors, `Projection ${statement.id} lifecycle references unknown field '${fieldName}' on ${entityId}`, entry.loc);
-        }
-      }
-    }
-  }
-}
-
-export function buildRegistry(workspaceAst, errors) {
-  const registry = new Map();
-
-  for (const file of workspaceAst.files) {
-    for (const statement of file.statements) {
-      if (!STATEMENT_KINDS.has(statement.kind)) {
-        if (statement.kind === "component") {
-          pushError(errors, `Statement kind ${renameDiagnostic("'component'", "'widget'", "widget widget_data_grid { ... }")}`, statement.loc);
-        } else {
-          pushError(errors, `Unknown statement kind '${statement.kind}'`, statement.loc);
-        }
-      }
-
-      if (!IDENTIFIER_PATTERN.test(statement.id)) {
-        pushError(errors, `Invalid identifier '${statement.id}'`, statement.loc);
-      }
-
-      if (registry.has(statement.id)) {
-        pushError(errors, `Duplicate statement id '${statement.id}'`, statement.loc);
-        continue;
-      }
-
-      registry.set(statement.id, statement);
-    }
-  }
-
-  return registry;
-}
-
-function validateDocs(workspaceAst, registry, errors) {
-  const docs = workspaceAst.docs || [];
-  const docRegistry = new Map();
-
-  for (const doc of docs) {
-    if (doc.parseError) {
-      pushError(errors, doc.parseError.message, doc.parseError.loc);
-      continue;
-    }
-
-    const { metadata } = doc;
-    for (const required of ["id", "kind", "title", "status"]) {
-      if (!metadata[required]) {
-        pushError(errors, `Missing required doc metadata '${required}'`, doc.loc);
-      }
-    }
-
-    if (metadata.id && !IDENTIFIER_PATTERN.test(metadata.id)) {
-      pushError(errors, `Invalid doc identifier '${metadata.id}'`, doc.loc);
-    }
-
-    if (metadata.kind && !DOC_KINDS.has(metadata.kind)) {
-      pushError(errors, `Unsupported doc kind '${metadata.kind}'`, doc.loc);
-    }
-
-    if (metadata.status && !DOC_STATUSES.has(metadata.status)) {
-      pushError(errors, `Unsupported doc status '${metadata.status}'`, doc.loc);
-    }
-
-    if (metadata.confidence && !DOC_CONFIDENCE.has(metadata.confidence)) {
-      pushError(errors, `Unsupported doc confidence '${metadata.confidence}'`, doc.loc);
-    }
-
-    if (metadata.review_required != null && typeof metadata.review_required !== "boolean") {
-      pushError(errors, "Doc metadata 'review_required' must be a boolean", doc.loc);
-    }
-
-    for (const key of DOC_ARRAY_FIELDS) {
-      if (metadata[key] != null && !Array.isArray(metadata[key])) {
-        pushError(errors, `Doc metadata '${key}' must be a list`, doc.loc);
-      }
-    }
-
-    if (metadata.id) {
-      if (docRegistry.has(metadata.id)) {
-        pushError(errors, `Duplicate doc id '${metadata.id}'`, doc.loc);
-      } else {
-        docRegistry.set(metadata.id, doc);
-      }
-    }
-  }
-
-  for (const doc of docs) {
-    if (doc.parseError) {
-      continue;
-    }
-    const { metadata } = doc;
-
-    for (const entityId of metadata.related_entities || []) {
-      const statement = registry.get(entityId);
-      if (!statement || statement.kind !== "entity") {
-        pushError(errors, `Doc '${metadata.id}' references missing entity '${entityId}'`, doc.loc);
-      }
-    }
-
-    for (const capabilityId of metadata.related_capabilities || []) {
-      const statement = registry.get(capabilityId);
-      if (!statement || statement.kind !== "capability") {
-        pushError(errors, `Doc '${metadata.id}' references missing capability '${capabilityId}'`, doc.loc);
-      }
-    }
-
-    for (const actorId of metadata.related_actors || []) {
-      const statement = registry.get(actorId);
-      if (!statement || statement.kind !== "actor") {
-        pushError(errors, `Doc '${metadata.id}' references missing actor '${actorId}'`, doc.loc);
-      }
-    }
-
-    for (const roleId of metadata.related_roles || []) {
-      const statement = registry.get(roleId);
-      if (!statement || statement.kind !== "role") {
-        pushError(errors, `Doc '${metadata.id}' references missing role '${roleId}'`, doc.loc);
-      }
-    }
-
-    for (const ruleId of metadata.related_rules || []) {
-      const statement = registry.get(ruleId);
-      if (!statement || statement.kind !== "rule") {
-        pushError(errors, `Doc '${metadata.id}' references missing rule '${ruleId}'`, doc.loc);
-      }
-    }
-
-    for (const workflowDocId of metadata.related_workflows || []) {
-      const relatedDoc = docRegistry.get(workflowDocId);
-      if (!relatedDoc || relatedDoc.metadata.kind !== "workflow") {
-        pushError(errors, `Doc '${metadata.id}' references missing workflow doc '${workflowDocId}'`, doc.loc);
-      }
-    }
-
-    for (const decisionId of metadata.related_decisions || []) {
-      const statement = registry.get(decisionId);
-      if (!statement || statement.kind !== "decision") {
-        pushError(errors, `Doc '${metadata.id}' references missing decision '${decisionId}'`, doc.loc);
-      }
-    }
-
-    for (const shapeId of metadata.related_shapes || []) {
-      const statement = registry.get(shapeId);
-      if (!statement || statement.kind !== "shape") {
-        pushError(errors, `Doc '${metadata.id}' references missing shape '${shapeId}'`, doc.loc);
-      }
-    }
-
-    for (const projectionId of metadata.related_projections || []) {
-      const statement = registry.get(projectionId);
-      if (!statement || statement.kind !== "projection") {
-        pushError(errors, `Doc '${metadata.id}' references missing projection '${projectionId}'`, doc.loc);
-      }
-    }
-
-    for (const relatedDocId of metadata.related_docs || []) {
-      if (!docRegistry.has(relatedDocId)) {
-        pushError(errors, `Doc '${metadata.id}' references missing doc '${relatedDocId}'`, doc.loc);
-      }
-    }
-
-    for (const [fieldName, expectedKind] of Object.entries(DOC_REFERENCE_FIELDS)) {
-      const value = metadata[fieldName];
-      if (value == null) continue;
-      if (typeof value !== "string") {
-        pushError(errors, `Doc metadata '${fieldName}' must be a single id`, doc.loc);
-        continue;
-      }
-      const target = registry.get(value);
-      if (!target) {
-        pushError(errors, `Doc '${metadata.id}' references missing ${expectedKind} '${value}'`, doc.loc);
-        continue;
-      }
-      if (target.kind !== expectedKind) {
-        pushError(
-          errors,
-          `Doc '${metadata.id}' ${fieldName} must reference a ${expectedKind}, found ${target.kind} '${target.id}'`,
-          doc.loc
-        );
-      }
-    }
-  }
-}
+export {
+  blockEntries,
+  collectFieldMap,
+  formatLoc,
+  getField,
+  getFieldValue,
+  pushError,
+  stringValue,
+  symbolValue,
+  symbolValues,
+  valueAsArray
+} from "./utils.js";
+
+export { buildRegistry } from "./registry.js";
 
 export function validateWorkspace(workspaceAst) {
   const errors = [];
@@ -3603,49 +86,13 @@ export function validateWorkspace(workspaceAst) {
   for (const file of workspaceAst.files) {
     for (const statement of file.statements) {
       const fieldMap = collectFieldMap(statement);
-      validateFieldPresence(errors, statement, fieldMap);
-      validateProjectionTypeRenames(errors, statement, fieldMap);
-      validateFieldShapes(errors, statement, fieldMap);
-      validateStatus(errors, statement, fieldMap);
-      validateRuleSeverity(errors, statement, fieldMap);
-      validateVerification(errors, statement, fieldMap);
+      validateCoreStatement(errors, statement, fieldMap);
       validateShapeFrom(errors, statement, registry);
-      validateReferenceKinds(errors, statement, fieldMap, registry);
-      validateEntityRelations(errors, statement, fieldMap, registry);
-      validateShapeTransforms(errors, statement, fieldMap, registry);
-      validateProjectionHttp(errors, statement, fieldMap, registry);
-      validateProjectionHttpErrors(errors, statement, fieldMap, registry);
-      validateProjectionHttpFields(errors, statement, fieldMap, registry);
-      validateProjectionHttpResponses(errors, statement, fieldMap, registry);
-      validateProjectionHttpPreconditions(errors, statement, fieldMap, registry);
-      validateProjectionHttpIdempotency(errors, statement, fieldMap, registry);
-      validateProjectionHttpCache(errors, statement, fieldMap, registry);
-      validateProjectionHttpDelete(errors, statement, fieldMap, registry);
-      validateProjectionHttpAsync(errors, statement, fieldMap, registry);
-      validateProjectionHttpStatus(errors, statement, fieldMap, registry);
-      validateProjectionHttpDownload(errors, statement, fieldMap, registry);
-      validateProjectionHttpAuthz(errors, statement, fieldMap, registry);
-      validateProjectionHttpCallbacks(errors, statement, fieldMap, registry);
-      validateProjectionUiOwnership(errors, statement, fieldMap);
-      validateProjectionUiScreens(errors, statement, fieldMap, registry);
-      validateProjectionUiCollections(errors, statement, fieldMap, registry);
-      validateProjectionUiActions(errors, statement, fieldMap, registry);
-      validateProjectionUiVisibility(errors, statement, fieldMap, registry);
-      validateProjectionUiLookups(errors, statement, fieldMap, registry);
-      validateProjectionUiRoutes(errors, statement, fieldMap, registry);
-      validateProjectionUiAppShell(errors, statement, fieldMap);
-      validateProjectionUiDesign(errors, statement, fieldMap);
-      validateProjectionUiNavigation(errors, statement, fieldMap, registry);
-      validateProjectionUiScreenRegions(errors, statement, fieldMap, registry);
-      validateProjectionUiComponents(errors, statement, fieldMap, registry);
-      validateProjectionUiWeb(errors, statement, fieldMap, registry);
-      validateProjectionUiIos(errors, statement, fieldMap, registry);
-      validateProjectionDbTables(errors, statement, fieldMap, registry);
-      validateProjectionDbColumns(errors, statement, fieldMap, registry);
-      validateProjectionDbKeys(errors, statement, fieldMap, registry);
-      validateProjectionDbIndexes(errors, statement, fieldMap, registry);
-      validateProjectionDbRelations(errors, statement, fieldMap, registry);
-      validateProjectionDbLifecycle(errors, statement, fieldMap, registry);
+      validateReferenceRules(errors, statement, fieldMap, registry);
+      validateDataModelStatement(errors, statement, fieldMap, registry);
+      validateApiHttpProjection(errors, statement, fieldMap, registry);
+      validateUiProjection(errors, statement, fieldMap, registry);
+      validateDbProjection(errors, statement, fieldMap, registry);
       validateProjectionGeneratorDefaults(errors, statement, fieldMap);
       validateWidget(errors, statement, fieldMap, registry);
       validateDomain(errors, statement, fieldMap, registry);