@facilis.dev/ai 0.0.0-stage → 0.1.1

package/src/manifest-facts.ts

@@ -0,0 +1,54 @@
+/**
+ * Defensive reader for the live `/__facilis/manifest` payload (SPEC §6.2).
+ *
+ * Only two things still come from the manifest: the registered blocks (reviewed supply
+ * chain, not a source fact) and a locale-catalogue fallback. Config, schema and routes are
+ * read from @facilis.dev/analyze's source facts (D-092); the manifest is data from a running
+ * app, not a trusted compiler output, so an unexpected shape yields fewer facts and never
+ * an exception.
+ */
+
+import type { BlockFacts } from "./types.ts";
+
+export interface ManifestFacts {
+  readonly blocks: readonly BlockFacts[];
+  readonly locales: Readonly<Record<string, string>>;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function factsFromBlocks(value: unknown): BlockFacts[] {
+  if (!Array.isArray(value)) return [];
+  return value.flatMap((entry) =>
+    isRecord(entry) && typeof entry.name === "string" ? [{ name: entry.name }] : [],
+  );
+}
+
+/** Prefer the default locale, fall back to English, then to the first object catalogue. */
+function factsFromCatalog(value: unknown, defaultLocale: string | null): Record<string, string> {
+  if (!isRecord(value)) return {};
+  const preferred = defaultLocale !== null && isRecord(value[defaultLocale]) ? defaultLocale : "en";
+  const locale = isRecord(value[preferred])
+    ? preferred
+    : Object.keys(value).find((candidate) => isRecord(value[candidate]));
+  const catalog = locale === undefined ? undefined : value[locale];
+  if (!isRecord(catalog)) return {};
+  const strings: Record<string, string> = {};
+  for (const [key, text] of Object.entries(catalog)) {
+    if (typeof text === "string") strings[key] = text;
+  }
+  return strings;
+}
+
+/** Read whatever the manifest is allowed to contribute; a broken payload yields zero facts. */
+export function factsFromManifest(manifest: unknown): ManifestFacts {
+  const root = isRecord(manifest) ? manifest : {};
+  const i18n = isRecord(root.i18n) ? root.i18n : {};
+  const defaultLocale = typeof i18n.defaultLocale === "string" ? i18n.defaultLocale : null;
+  return {
+    blocks: factsFromBlocks(root.blocks),
+    locales: factsFromCatalog(i18n.catalogs, defaultLocale),
+  };
+}

package/src/node.ts

@@ -0,0 +1,75 @@
+/**
+ * Node-only helpers, exported as `@facilis.dev/ai/node` (D-084, D-092).
+ *
+ * The main entry must stay browser-safe, so this subpath is the only place that imports
+ * runtime code from a parser: rule 1's rolldown `parseSync` (oxc) and, for tests/tooling,
+ * @facilis.dev/analyze's oxc adapter so a project file map can be analyzed without a browser.
+ * The IDE never imports this module: it injects the analyzer worker's oxc parser instead.
+ */
+
+import { analyzeProject, type Analysis, type PathAlias } from "@facilis.dev/analyze";
+import { createOxcParser as createAnalyzerParser } from "@facilis.dev/analyze/node";
+import { parseSync } from "rolldown/utils";
+
+import type { SyntaxChecker, SyntaxIssue } from "./types.ts";
+
+export type ScriptLanguage = "ts" | "tsx" | "js" | "jsx";
+
+interface ParserError {
+  severity: string;
+  message: string;
+  labels?: readonly { start: number; end: number }[];
+}
+
+function languageOf(path: string): ScriptLanguage {
+  if (path.endsWith(".tsx")) return "tsx";
+  if (path.endsWith(".jsx")) return "jsx";
+  if (path.endsWith(".js") || path.endsWith(".mjs") || path.endsWith(".cjs")) return "js";
+  return "ts";
+}
+
+function positionOf(content: string, offset: number): { line: number; column: number } {
+  const bounded = Math.max(0, Math.min(offset, content.length));
+  const lines = content.slice(0, bounded).split("\n");
+  return { line: lines.length, column: (lines.at(-1)?.length ?? 0) + 1 };
+}
+
+function toIssue(content: string, error: ParserError): SyntaxIssue {
+  const label = error.labels?.[0];
+  const position = positionOf(content, label?.start ?? 0);
+  return { line: position.line, column: position.column, message: error.message };
+}
+
+/** A {@link SyntaxChecker} backed by rolldown's oxc parser (Node only). */
+export function createTypeScriptSyntaxChecker(): SyntaxChecker {
+  return {
+    async check(path, content) {
+      const language = languageOf(path);
+      try {
+        const result = parseSync(path, content, { lang: language });
+        return (result.errors as readonly ParserError[])
+          .filter((error) => error.severity === "Error")
+          .map((error) => toIssue(content, error));
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return [{ line: 1, column: 1, message }];
+      }
+    },
+  };
+}
+
+/**
+ * Analyze a project file map with the Node oxc parser. Tests/tooling only: the browser
+ * passes its own parser adapter to `analyzeProject`, and the main entry never imports
+ * this module (it would pull a parser into the IDE bundle).
+ */
+export function analyzeProjectSources(
+  files: ReadonlyMap<string, string>,
+  aliases?: readonly PathAlias[],
+): Analysis {
+  return analyzeProject({
+    files,
+    parser: createAnalyzerParser(),
+    ...(aliases === undefined ? {} : { aliases }),
+  });
+}

package/src/overlay.ts

@@ -0,0 +1,131 @@
+/**
+ * The pre-patch project context overlaid with one patch set.
+ *
+ * After D-092 this is fact-based: the caller supplies the effective (post-patch) Analysis
+ * and the pre-patch one, so the overlay only projects them plus the patch-shaped
+ * bookkeeping the rules need (file set, patched paths, removed facts). It never parses
+ * project sources; the one JSON read is the patched locale catalogue, because rule 13 must
+ * tell "no keys" from "broken catalogue". Pure and browser-safe.
+ */
+
+import type { Analysis, ConfigFacts, FileFacts, TableFact } from "@facilis.dev/analyze";
+
+import { LOCALES_PATH, normalizeProjectPath, SCHEMA_PATH } from "./paths.ts";
+import type { FilePatch, PatchContext } from "./types.ts";
+
+export { CONFIG_PATH, LOCALES_PATH, SCHEMA_PATH } from "./paths.ts";
+
+export interface EffectiveState {
+  /** Project-relative files that exist after the patch. */
+  files: ReadonlySet<string>;
+  /** Every path the patch touches, and those it deletes. */
+  patchedPaths: ReadonlySet<string>;
+  deletedPaths: ReadonlySet<string>;
+  /** Effective analysis + the pre-patch one, for inverse edits. */
+  analysis: Analysis;
+  before: Analysis;
+  /** Module facts of the created/updated files (from the effective analysis). */
+  patchedFileFacts: readonly FileFacts[];
+  /** Effective config after the patch (analyzer facts). */
+  config: ConfigFacts;
+  /** Every effective table, including framework tables re-exported into the schema. */
+  schemaTables: readonly TableFact[];
+  /** Tables declared in the code schema before and after the patch (no re-exports). */
+  beforeSchemaTables: readonly TableFact[];
+  afterSchemaTables: readonly TableFact[];
+  locales: Readonly<Record<string, string>>;
+  /** False when a patched locales/en.json is not a valid JSON catalogue. */
+  localesValid: boolean;
+  migrationsDir: string;
+  removedTables: readonly string[];
+  removedPermissions: readonly string[];
+}
+
+function parseCatalog(content: string): Record<string, string> | null {
+  try {
+    const parsed: unknown = JSON.parse(content);
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return null;
+    const catalog: Record<string, string> = {};
+    for (const [key, value] of Object.entries(parsed)) {
+      if (typeof value === "string") catalog[key] = value;
+    }
+    return catalog;
+  } catch {
+    return null;
+  }
+}
+
+/** A table the project declares in its own schema file (not a framework re-export). */
+function isSchemaTable(table: TableFact): boolean {
+  return normalizeProjectPath(table.source.file) === SCHEMA_PATH;
+}
+
+/** True when the patch creates a SQL migration file in the configured directory. */
+export function hasMigrationPatch(patches: readonly FilePatch[], migrationsDir: string): boolean {
+  const directory = normalizeProjectPath(migrationsDir).replace(/\/+$/, "");
+  return patches.some(
+    (patch) =>
+      patch.action === "create" &&
+      normalizeProjectPath(patch.path).startsWith(directory + "/") &&
+      normalizeProjectPath(patch.path).endsWith(".sql"),
+  );
+}
+
+/** Overlay the patch set onto the project context. */
+export function buildEffectiveState(
+  context: PatchContext,
+  patches: readonly FilePatch[],
+): EffectiveState {
+  const patched = new Map<string, string>();
+  const deleted = new Set<string>();
+  const patchedPaths = new Set<string>();
+  for (const patch of patches) {
+    const path = normalizeProjectPath(patch.path);
+    patchedPaths.add(path);
+    if (patch.action === "delete") deleted.add(path);
+    else if (typeof patch.content === "string") patched.set(path, patch.content);
+  }
+
+  const analysis = context.analysis;
+  const before = context.before;
+  const config = analysis.config;
+  const beforeSchemaTables = before.tables.filter(isSchemaTable);
+  const afterSchemaTables = analysis.tables.filter(isSchemaTable);
+  const afterNames = new Set(afterSchemaTables.map((table) => table.name));
+  const beforeNames = new Set(beforeSchemaTables.map((table) => table.name));
+
+  let locales = context.locales;
+  let localesValid = true;
+  const catalogContent = patched.get(LOCALES_PATH);
+  if (catalogContent !== undefined) {
+    const catalog = parseCatalog(catalogContent);
+    if (catalog === null) localesValid = false;
+    else locales = catalog;
+  }
+
+  const files = new Set(context.files.map(normalizeProjectPath));
+  for (const path of deleted) files.delete(path);
+  for (const path of patched.keys()) files.add(path);
+
+  return {
+    files,
+    patchedPaths,
+    deletedPaths: deleted,
+    analysis,
+    before,
+    patchedFileFacts: analysis.fileFacts.filter((facts) =>
+      patchedPaths.has(normalizeProjectPath(facts.path)),
+    ),
+    config,
+    schemaTables: analysis.tables,
+    beforeSchemaTables,
+    afterSchemaTables,
+    locales,
+    localesValid,
+    migrationsDir: normalizeProjectPath(config.migrationsDir),
+    removedTables: [...beforeNames].filter((name) => !afterNames.has(name)),
+    removedPermissions: before.config.permissions.filter(
+      (permission) => !config.permissions.includes(permission),
+    ),
+  };
+}

package/src/paths.ts

@@ -0,0 +1,80 @@
+/**
+ * Project-relative path predicates shared by the validator rules (SPEC §9.3 rule 11).
+ *
+ * Paths are always compared in their normalized, root-relative form ("src/App.tsx"), so
+ * Windows separators or a leading "./" never change a rule's verdict.
+ *
+ * Rule 11's writable set follows the deployment profile (D-167). A `managed` build keeps
+ * the six source roots (D-084); an `open` build accepts the whole project minus the
+ * machine surfaces a patch must never touch: dependencies, install state, VCS/IDE state,
+ * build output and the project's own instruction file.
+ */
+
+import type { WritePolicy } from "./types.ts";
+
+const SCRIPT_EXTENSIONS = [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"];
+
+/** The project files whose facts the validator treats specially. */
+export const CONFIG_PATH = "facilis.config.ts";
+export const SCHEMA_PATH = "db/schema.ts";
+export const LOCALES_PATH = "locales/en.json";
+
+/** Roots a `managed` patch may write to (SPEC §9.3 rule 11, D-084). */
+export const ALLOWED_ROOTS = ["server/", "src/", "db/", "lib/", "components/", "locales/"];
+
+/**
+ * The one root file a `managed` patch may touch: rule 16 exists because a new
+ * permission/role is declared in facilis.config.ts in the same patch, so a blanket
+ * root-file rejection would make the 17-rule contract self-contradictory (D-084).
+ */
+export const ALLOWED_ROOT_FILES = new Set(["facilis.config.ts"]);
+
+/**
+ * Directory segments no `open` patch may write into (D-167). They are the same entries
+ * the PTC read policy hides (docs/PTC.md §6): dependencies, VCS and IDE state, and build
+ * output the Explorer does not review. A patch writing them could hide its own changes,
+ * poison a cache, or add code without an install.
+ */
+export const DENIED_SEGMENTS = new Set([
+  "node_modules",
+  ".git",
+  ".facilis",
+  "dist",
+  ".turbo",
+  "coverage",
+]);
+
+/**
+ * File names no `open` patch may write (D-167). The install surface is the dependency
+ * manifest, the lockfiles and the npm config; AGENTS.md stays IDE-writer-only because it
+ * persists instructions into every later session (D-084).
+ */
+export const DENIED_FILES = new Set([
+  "package.json",
+  "package-lock.json",
+  "npm-shrinkwrap.json",
+  "pnpm-lock.yaml",
+  "yarn.lock",
+  ".npmrc",
+  "AGENTS.md",
+]);
+
+export function normalizeProjectPath(path: string): string {
+  let normalized = path.trim();
+  while (normalized.startsWith("./")) normalized = normalized.slice(2);
+  return normalized.replace(/^\/+/, "");
+}
+
+export function isScriptPath(path: string): boolean {
+  return SCRIPT_EXTENSIONS.some((extension) => path.endsWith(extension));
+}
+
+/** True when the normalized path is writable under `policy` (rule 11). */
+export function isAllowedWritePath(path: string, policy: WritePolicy = "managed"): boolean {
+  if (policy === "managed") {
+    return ALLOWED_ROOT_FILES.has(path) || ALLOWED_ROOTS.some((root) => path.startsWith(root));
+  }
+  const segments = path.split("/");
+  const name = segments[segments.length - 1] ?? "";
+  return !DENIED_FILES.has(name) && !segments.some((segment) => DENIED_SEGMENTS.has(segment));
+}

package/src/rules/blocks.ts

@@ -0,0 +1,67 @@
+/**
+ * Rule 7 `block-import-valid` (SPEC §9.3): every block the patch imports must match a
+ * registered `BlockManifest`. The block supply chain is retired (D-131, no `@facilis.dev/blocks`
+ * package ships), so in practice the manifest registers none and the guard rejects every block
+ * import; it stays in the rule set as the contract's reserved slot (§7.2/§7.3).
+ *
+ * The imports are the analyzer's FileFacts, so re-exports and dynamic imports are covered
+ * by the same AST truth the rest of validation uses.
+ */
+
+import type { EffectiveState } from "../overlay.ts";
+import type { ImportFact, PatchContext, ValidationError } from "../types.ts";
+
+const DEFAULT_BLOCKS_PACKAGE = "@facilis.dev/blocks";
+
+/** The import names a block import introduces: named imports and default-import locals. */
+function namesOf(imported: ImportFact): string[] {
+  if (imported.kind === "named" && imported.imported !== null) return [imported.imported];
+  if (imported.kind === "default" && imported.local !== null) return [imported.local];
+  return [];
+}
+
+/** The block name an import points at, or null when the specifier is not a block import. */
+function blockNameFromPath(specifier: string, packages: ReadonlySet<string>): string | null {
+  for (const pkg of packages) {
+    if (specifier === pkg) return null;
+    if (specifier.startsWith(pkg + "/")) {
+      const name = specifier.slice(pkg.length + 1).split("/")[0];
+      return name === undefined || name.length === 0 ? null : name;
+    }
+  }
+  const segments = specifier.split("/");
+  const index = segments.indexOf("blocks");
+  if (index === -1) return null;
+  const name = segments[index + 1];
+  return name === undefined || name.length === 0 ? null : name;
+}
+
+export function blockImportErrors(state: EffectiveState, context: PatchContext): ValidationError[] {
+  // Blocks are no longer configurable: the framework ships one reviewed package (D-067).
+  const packages = new Set([DEFAULT_BLOCKS_PACKAGE]);
+  const known = new Set(context.blocks.map((block) => block.name));
+  const errors: ValidationError[] = [];
+  const seen = new Set<string>();
+  for (const facts of state.patchedFileFacts) {
+    for (const imported of facts.imports) {
+      const fromPackageRoot = packages.has(imported.specifier);
+      const pathName = blockNameFromPath(imported.specifier, packages);
+      const candidates = fromPackageRoot ? namesOf(imported) : pathName === null ? [] : [pathName];
+      for (const candidate of candidates) {
+        const key = facts.path + "\u0000" + candidate;
+        if (known.has(candidate) || seen.has(key)) continue;
+        seen.add(key);
+        errors.push({
+          rule: "block-import-valid",
+          severity: "error",
+          file: facts.path,
+          message: 'Block import "' + candidate + '" does not match a registered BlockManifest.',
+          fix_hint:
+            "Import an existing block manifest, or stop importing it; do not create new blocks unprompted (SPEC §9.2 rule 5).",
+          line: imported.source.line,
+        });
+      }
+    }
+  }
+  return errors;
+}

package/src/rules/config-sync.ts

@@ -0,0 +1,72 @@
+/**
+ * Rule 16 `role-config-sync` (SPEC §9.3): changing roles or permissions in
+ * `facilis.config.ts` requires a new migration that updates the `role_permissions`
+ * seed. The table is a projection of the config (SPEC §5.3), so without the migration the
+ * live database silently disagrees with the code.
+ */
+
+import { hasMigrationPatch, CONFIG_PATH, type EffectiveState } from "../overlay.ts";
+import { normalizeProjectPath } from "../paths.ts";
+import type { ConfigFacts, FilePatch, ValidationError } from "../types.ts";
+
+function changedFacts(before: ConfigFacts, after: ConfigFacts): string[] {
+  const changes: string[] = [];
+  for (const permission of after.permissions) {
+    if (!before.permissions.includes(permission))
+      changes.push('adds permission "' + permission + '"');
+  }
+  for (const permission of before.permissions) {
+    if (!after.permissions.includes(permission))
+      changes.push('removes permission "' + permission + '"');
+  }
+  const beforeRoles = JSON.stringify(before.roles);
+  const afterRoles = JSON.stringify(after.roles);
+  if (beforeRoles !== afterRoles) changes.push("changes auth.roles");
+  if ((before.defaultRole ?? "") !== (after.defaultRole ?? "")) {
+    changes.push('changes defaultRole to "' + (after.defaultRole ?? "") + '"');
+  }
+  return changes;
+}
+
+export function roleConfigSyncErrors(
+  patches: readonly FilePatch[],
+  state: EffectiveState,
+): ValidationError[] {
+  const touchesConfig = patches.some((patch) => {
+    return normalizeProjectPath(patch.path) === CONFIG_PATH && patch.action !== "delete";
+  });
+  if (!touchesConfig) return [];
+  const errors: ValidationError[] = [];
+  const after = state.config;
+  // A config patch the scan cannot read is unverifiable: rule 16 fails closed instead of
+  // assuming "no auth change". The pre-patch source may be unparseable for the same
+  // reason, so the check is on the patched content itself.
+  if (!after.parsed) {
+    errors.push({
+      rule: "role-config-sync",
+      severity: "error",
+      file: CONFIG_PATH,
+      message:
+        "The auth block of the patched facilis.config.ts could not be read, so the role/permission sync cannot be verified.",
+      fix_hint:
+        "Keep the auth declaration as an object literal inside defineConfig so the validator can read it.",
+    });
+    return errors;
+  }
+  const changes = changedFacts(state.before.config, after);
+  if (changes.length === 0 || hasMigrationPatch(patches, state.migrationsDir)) return [];
+  errors.push({
+    rule: "role-config-sync",
+    severity: "error",
+    file: CONFIG_PATH,
+    message:
+      "The patch " +
+      changes.slice(0, 3).join(", ") +
+      " but ships no migration updating role_permissions.",
+    fix_hint:
+      "Add a migration under " +
+      state.migrationsDir +
+      "/ that reseeds role_permissions from the config (SPEC §5.3, rule 16).",
+  });
+  return errors;
+}

package/src/rules/database.ts

@@ -0,0 +1,139 @@
+/**
+ * Rules 10 `rls-on-scoped-table`, 14 `migration-generated` and 15
+ * `destructive-confirmed` (SPEC §9.3), read from the effective code schema.
+ *
+ * Only tables the project declares itself count (`source.file === db/schema.ts`): the
+ * framework tables re-exported from `@facilis.dev/auth` ship their own RLS and must not be
+ * re-flagged here. Scope is the analyzer's ScopeFact or a tenant/owner column property.
+ */
+
+import type { EffectiveState } from "../overlay.ts";
+import { hasMigrationPatch, SCHEMA_PATH } from "../overlay.ts";
+import { normalizeProjectPath } from "../paths.ts";
+import type { FilePatch, TableFact, ValidationError } from "../types.ts";
+
+function error(rule: string, file: string, message: string, fix_hint: string): ValidationError {
+  return { rule, severity: "error", file, message, fix_hint };
+}
+
+function warning(rule: string, file: string, message: string, fix_hint: string): ValidationError {
+  return { rule, severity: "warning", file, message, fix_hint };
+}
+
+/** True when this patch set touches the project schema file (create, update or delete). */
+function touchesSchema(state: EffectiveState): boolean {
+  return state.patchedPaths.has(SCHEMA_PATH) || state.deletedPaths.has(SCHEMA_PATH);
+}
+
+function normalized(value: string): string {
+  return value.replaceAll("_", "").replaceAll("-", "").toLowerCase();
+}
+
+/** A table is scoped when the analyzer saw a scope or a configured tenant/owner column. */
+function isScoped(
+  table: TableFact,
+  tenantColumns: readonly string[],
+  ownerColumns: readonly string[],
+): boolean {
+  if (table.scope !== null) return true;
+  const names = new Set([...tenantColumns, ...ownerColumns].map(normalized));
+  return table.columns.some(
+    (column) => names.has(normalized(column.property)) || names.has(normalized(column.name)),
+  );
+}
+
+/**
+ * Rule 10: a schema rewrite is a complete re-emission of the schema, so every scoped table
+ * in the result must ship its RLS policy — .enableRLS() plus a policy (invariant 4). The
+ * check is not limited to new tables: dropping the policy from an existing scoped table is
+ * the same security regression.
+ */
+export function rlsErrors(state: EffectiveState): ValidationError[] {
+  if (!touchesSchema(state)) return [];
+  const errors: ValidationError[] = [];
+  for (const table of state.afterSchemaTables) {
+    if (!isScoped(table, state.config.tenantColumns, state.config.ownerColumns)) continue;
+    if (table.rlsEnabled && table.policies.length > 0) continue;
+    errors.push(
+      error(
+        "rls-on-scoped-table",
+        SCHEMA_PATH,
+        'Scoped table "' + table.name + '" has no RLS policy in the patched db/schema.ts.',
+        "Add .enableRLS() and a tenantIsolationPolicy()/ownerIsolationPolicy() (or pgPolicy) to the table in db/schema.ts (invariant 4).",
+      ),
+    );
+  }
+  return errors;
+}
+
+/** Rule 14: a schema edit must ship a generated migration file (warning). */
+export function migrationWarnings(
+  patches: readonly FilePatch[],
+  state: EffectiveState,
+): ValidationError[] {
+  const touches = patches.some((patch) => {
+    const path = normalizeProjectPath(patch.path);
+    return path === SCHEMA_PATH && patch.action !== "delete";
+  });
+  if (!touches) return [];
+  if (hasMigrationPatch(patches, state.migrationsDir)) return [];
+  return [
+    warning(
+      "migration-generated",
+      SCHEMA_PATH,
+      "The patch changes the schema without shipping a migration.",
+      "Add the drizzle-kit generated migration (.sql) under " +
+        state.migrationsDir +
+        "/ in the same patch.",
+    ),
+  ];
+}
+
+function removedColumns(before: readonly TableFact[], after: readonly TableFact[]): string[] {
+  const afterByName = new Map(after.map((table) => [table.name, table]));
+  const removed: string[] = [];
+  for (const table of before) {
+    const current = afterByName.get(table.name);
+    if (current === undefined || table.columns.length === 0 || current.columns.length === 0) {
+      continue;
+    }
+    const currentColumns = new Set(current.columns.map((column) => column.property));
+    for (const column of table.columns) {
+      if (!currentColumns.has(column.property)) removed.push(table.name + "." + column.property);
+    }
+  }
+  return removed;
+}
+
+/** The schema removals in a patch set (rule 15's predicate), for callers that need the
+ * fact without the finding (the IDE flags a write destructive, never blocks it). */
+export function destructiveChanges(state: EffectiveState): string[] {
+  const afterNames = new Set(state.afterSchemaTables.map((table) => table.name));
+  const droppedTables = state.beforeSchemaTables
+    .map((table) => table.name)
+    .filter((name) => !afterNames.has(name));
+  const droppedColumns = removedColumns(state.beforeSchemaTables, state.afterSchemaTables);
+  return [
+    ...droppedTables.map((name) => 'drops table "' + name + '"'),
+    ...droppedColumns.map((name) => 'drops column "' + name + '"'),
+  ];
+}
+
+/** Rule 15: dropping a table or column is destructive and must be confirmed. */
+export function destructiveErrors(
+  state: EffectiveState,
+  requiresConfirmation: boolean,
+): ValidationError[] {
+  const changes = destructiveChanges(state);
+  if (changes.length === 0 || requiresConfirmation) return [];
+  const shown = changes.slice(0, 3).join(", ");
+  const suffix = changes.length > 3 ? " (and " + (changes.length - 3) + " more)" : "";
+  return [
+    error(
+      "destructive-confirmed",
+      SCHEMA_PATH,
+      "Destructive schema change without confirmation: the patch " + shown + suffix + ".",
+      "If the removal was not intended, re-emit the complete db/schema.ts keeping every existing table and column and add only the requested change. For a deliberate removal, set requires_confirmation to true and explain it in notes (SPEC §9.2 rule 9 / §9.3 rule 15).",
+    ),
+  ];
+}

package/src/rules/i18n.ts

@@ -0,0 +1,42 @@
+/**
+ * Rule 13 `i18n-keys-registered` (warning, SPEC §9.3): every static `t("key")` call in
+ * a patched file must have its key in the effective default-locale catalogue. Keys are
+ * literal facts from the analyzer: an interpolated key cannot be checked and guessing would
+ * produce false warnings.
+ */
+
+import { LOCALES_PATH, type EffectiveState } from "../overlay.ts";
+import { isScriptPath } from "../paths.ts";
+import type { ValidationError } from "../types.ts";
+
+export function i18nWarnings(state: EffectiveState): ValidationError[] {
+  const warnings: ValidationError[] = [];
+  if (!state.localesValid) {
+    warnings.push({
+      rule: "i18n-keys-registered",
+      severity: "warning",
+      file: LOCALES_PATH,
+      message:
+        "The patched locales/en.json is not a valid JSON catalogue, so i18n keys cannot be verified.",
+      fix_hint: "Emit locales/en.json as a complete JSON object of key/value strings.",
+    });
+  }
+  const known = new Set(Object.keys(state.locales));
+  for (const facts of state.patchedFileFacts) {
+    if (!isScriptPath(facts.path)) continue;
+    const reported = new Set<string>();
+    for (const call of facts.translationCalls) {
+      if (known.has(call.key) || reported.has(call.key)) continue;
+      reported.add(call.key);
+      warnings.push({
+        rule: "i18n-keys-registered",
+        severity: "warning",
+        file: facts.path,
+        message: 't("' + call.key + '") is not registered in locales/en.json.',
+        fix_hint: "Add the key to locales/en.json in the same patch, or reuse a registered key.",
+        line: call.source.line,
+      });
+    }
+  }
+  return warnings;
+}