@dowel/dowel 0.0.1 → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 SwiftCom
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,10 +1,55 @@
 # dowel
 
-An opinionated, compiled **architecture linter**. It enforces structural rules
-so a codebase stays consistent enough for humans *and* coding agents to extend
-safely — a dowel is the pin that joins two structural members, and this tool
-holds a codebase's architecture together the same way.
+A compiled, opinionated **architecture linter**. Rules surface diagnostics +
+intent; the agent reading them applies the fix. Unlike a type-checker it also
+validates raw SQL against a real schema — it builds a shadow Postgres from your
+migrations and `PREPARE`s every query against it.
 
-This `0.0.0` publish reserves the name. The real release is coming soon.
+This package ships the Rust engine as a native Node addon plus a TypeScript
+authoring API, so you write your codebase's architecture rules in TypeScript:
 
-Source: https://github.com/swiftcomza/arch-lint
+```ts
+// rules/no-sql-outside-repos.ts
+import { defineRule } from "@dowel/dowel";
+
+export default defineRule({
+  id: "NO_SQL_OUTSIDE_REPOS",
+  intent: "raw SQL lives only in repos/ — services compose, repos query",
+  check(project) {
+    return project
+      .files()
+      .filter((f) => /\bselect\b/i.test(f.text) && !f.relPath.includes("/repos/"))
+      .map((f) => ({ severity: "error", file: f.path, line: 1, message: "move SQL into a repo" }));
+  },
+});
+```
+
+## Install
+
+```bash
+npm i -D @dowel/dowel
+```
+
+npm pulls exactly one prebuilt native package for your platform
+(`@dowel/dowel-<triple>`) via `optionalDependencies` — no Rust toolchain, no
+post-install compile, no committed binary.
+
+## Use
+
+Add an `arch-lint.toml` and a `rules/` dir, then:
+
+```jsonc
+// package.json
+"scripts": { "lint:arch": "dowel" }
+```
+
+```bash
+npx dowel                 # lint cwd against ./arch-lint.toml + ./rules
+dowel --root ../ --config arch-lint.toml --rules rules
+```
+
+Exit code is non-zero on any `error`-severity diagnostic, so it gates CI.
+
+## License
+
+MIT

package/bin/dowel.mjs

@@ -0,0 +1,98 @@
+#!/usr/bin/env node
+// dowel — the architecture linter CLI (plan 005 §2; the consumer-side runner).
+//
+// Loads every TS rule under the rules dir, runs the native packs + all TS rules
+// through the native addon, prints diagnostics, and exits non-zero on any error.
+//
+// Usage (run from the dir holding arch-lint.toml + rules/, or pass flags):
+//   dowel [--root <project>] [--config <arch-lint.toml>] [--rules <dir>] [--no-db]
+//
+// Defaults: --config ./arch-lint.toml, --rules <dir-of-config>/rules,
+//           --root  current working directory.
+
+import { readdirSync, existsSync } from "node:fs";
+import { dirname, isAbsolute, join, resolve } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+// Consumer rules are authored in TypeScript; importing them needs Node's
+// type-stripping. It's unflagged on Node >= 22.18 / 23, flagged before that.
+// If this process can't strip types, re-exec ourselves with the flag once.
+if (!process.features?.typescript && !process.env.__DOWEL_TS) {
+  const { spawnSync } = await import("node:child_process");
+  const self = fileURLToPath(import.meta.url);
+  const r = spawnSync(
+    process.execPath,
+    ["--experimental-strip-types", self, ...process.argv.slice(2)],
+    { stdio: "inherit", env: { ...process.env, __DOWEL_TS: "1" } },
+  );
+  process.exit(r.status ?? 1);
+}
+
+const { runLint } = await import("../dist/runtime.js");
+
+function parseArgs(argv) {
+  const opts = { root: null, config: null, rules: null, withOracle: true };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--root") opts.root = argv[++i];
+    else if (a === "--config") opts.config = argv[++i];
+    else if (a === "--rules") opts.rules = argv[++i];
+    else if (a === "--no-db") opts.withOracle = false;
+    else if (a === "-h" || a === "--help") {
+      console.log(
+        "dowel — architecture linter\n\n" +
+          "Usage: dowel [--root <project>] [--config <arch-lint.toml>] [--rules <dir>] [--no-db]\n",
+      );
+      process.exit(0);
+    } else if (!a.startsWith("-") && opts.root === null) {
+      // bare positional → project root (back-compat with run.ts argv[2])
+      opts.root = a;
+    } else {
+      console.error(`dowel: unknown argument '${a}'`);
+      process.exit(2);
+    }
+  }
+  return opts;
+}
+
+function abs(p) {
+  return isAbsolute(p) ? p : resolve(process.cwd(), p);
+}
+
+const opts = parseArgs(process.argv.slice(2));
+
+const configPath = abs(opts.config ?? "arch-lint.toml");
+if (!existsSync(configPath)) {
+  console.error(`dowel: config not found: ${configPath}`);
+  console.error("  pass --config <path/to/arch-lint.toml> or run from its directory");
+  process.exit(2);
+}
+
+const rulesDir = abs(opts.rules ?? join(dirname(configPath), "rules"));
+const root = abs(opts.root ?? process.cwd());
+const withOracle = opts.withOracle && process.env.ARCH_LINT_NO_DB !== "1";
+
+async function loadRules() {
+  if (!existsSync(rulesDir)) return [];
+  const rules = [];
+  for (const name of readdirSync(rulesDir).sort()) {
+    if (!name.endsWith(".ts") || name.endsWith(".d.ts")) continue;
+    const mod = await import(pathToFileURL(join(rulesDir, name)).href);
+    if (mod.default) rules.push(mod.default);
+  }
+  return rules;
+}
+
+function format(d, root) {
+  const rel = d.file.startsWith(root) ? "." + d.file.slice(root.length) : d.file;
+  return `${d.severity}\t${rel}:${d.line}\t[${d.rule}] ${d.message}`;
+}
+
+const rules = await loadRules();
+const diags = runLint({ root, configPath, withOracle, rules });
+for (const d of diags) console.log(format(d, root));
+
+const errors = diags.filter((d) => d.severity === "error").length;
+const warnings = diags.filter((d) => d.severity === "warn").length;
+console.log(`\narch-lint-ts: ${errors} error(s), ${warnings} warning(s) [${rules.length} TS rules]`);
+process.exit(errors > 0 ? 1 : 0);

package/dist/binding.d.ts

@@ -0,0 +1,3 @@
+/** Resolve and load the native addon for the host triple. */
+export declare function loadAddon(): unknown;
+//# sourceMappingURL=binding.d.ts.map

package/dist/binding.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"binding.d.ts","sourceRoot":"","sources":["../binding.ts"],"names":[],"mappings":"AAgDA,6DAA6D;AAC7D,wBAAgB,SAAS,IAAI,OAAO,CAuBnC"}

package/dist/binding.js

@@ -0,0 +1,68 @@
+// binding.ts — platform-dispatch loader for the dowel native addon.
+//
+// The Rust crate is built with napi-derive v2 while we drive the build with
+// @napi-rs/cli v3; that version split means the CLI does not emit its usual
+// `index.js` dispatch table. This file reproduces that table by hand (the
+// resolution is deterministic and stable): compute the host platform key,
+// require the matching `@dowel/dowel-<key>` package's prebuilt `.node`, and
+// fall back to a locally-built addon for development. One match wins; npm only
+// installs the one platform package whose `os`/`cpu`/`libc` fit the host.
+import { createRequire } from "node:module";
+import { existsSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+const require = createRequire(import.meta.url);
+const here = dirname(fileURLToPath(import.meta.url));
+/** True on musl libc (Alpine) — picks `-musl` over `-gnu` on linux. */
+function isMusl() {
+    // node >= 18 exposes the runtime libc via process.report.
+    try {
+        const report = process.report?.getReport();
+        if (report && !report.header?.glibcVersionRuntime)
+            return true;
+    }
+    catch {
+        // ignore — fall through to false (assume glibc)
+    }
+    return false;
+}
+/** The napi platform key for the host (e.g. `darwin-arm64`, `linux-x64-musl`). */
+function platformKey() {
+    const { platform, arch } = process;
+    switch (platform) {
+        case "darwin":
+            return arch === "x64" ? "darwin-x64" : "darwin-arm64";
+        case "win32":
+            return "win32-x64-msvc";
+        case "linux":
+            if (arch === "arm64")
+                return "linux-arm64-gnu";
+            return isMusl() ? "linux-x64-musl" : "linux-x64-gnu";
+        default:
+            throw new Error(`dowel: unsupported platform ${platform}-${arch}`);
+    }
+}
+/** Resolve and load the native addon for the host triple. */
+export function loadAddon() {
+    const key = platformKey();
+    const file = `dowel.${key}.node`;
+    // 1. local build (dev): crate root, or sibling of this module.
+    for (const candidate of [
+        join(here, file),
+        join(here, "..", file),
+        join(here, "..", "npm", key, file),
+    ]) {
+        if (existsSync(candidate))
+            return require(candidate);
+    }
+    // 2. published per-platform package.
+    try {
+        return require(`@dowel/dowel-${key}`);
+    }
+    catch (cause) {
+        throw new Error(`dowel: failed to load the native addon for ${key}.\n` +
+            `Install the matching optional dependency (@dowel/dowel-${key}) or run \`napi build --release\`.\n` +
+            `Cause: ${cause.message}`);
+    }
+}
+//# sourceMappingURL=binding.js.map

package/dist/binding.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"binding.js","sourceRoot":"","sources":["../binding.ts"],"names":[],"mappings":"AAAA,oEAAoE;AACpE,EAAE;AACF,4EAA4E;AAC5E,4EAA4E;AAC5E,0EAA0E;AAC1E,0EAA0E;AAC1E,4EAA4E;AAC5E,+EAA+E;AAC/E,0EAA0E;AAE1E,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AACrC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAC1C,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAEzC,MAAM,OAAO,GAAG,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AAC/C,MAAM,IAAI,GAAG,OAAO,CAAC,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;AAErD,uEAAuE;AACvE,SAAS,MAAM;IACb,0DAA0D;IAC1D,IAAI,CAAC;QACH,MAAM,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,SAAS,EAE3B,CAAC;QACd,IAAI,MAAM,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE,mBAAmB;YAAE,OAAO,IAAI,CAAC;IACjE,CAAC;IAAC,MAAM,CAAC;QACP,gDAAgD;IAClD,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAED,kFAAkF;AAClF,SAAS,WAAW;IAClB,MAAM,EAAE,QAAQ,EAAE,IAAI,EAAE,GAAG,OAAO,CAAC;IACnC,QAAQ,QAAQ,EAAE,CAAC;QACjB,KAAK,QAAQ;YACX,OAAO,IAAI,KAAK,KAAK,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,cAAc,CAAC;QACxD,KAAK,OAAO;YACV,OAAO,gBAAgB,CAAC;QAC1B,KAAK,OAAO;YACV,IAAI,IAAI,KAAK,OAAO;gBAAE,OAAO,iBAAiB,CAAC;YAC/C,OAAO,MAAM,EAAE,CAAC,CAAC,CAAC,gBAAgB,CAAC,CAAC,CAAC,eAAe,CAAC;QACvD;YACE,MAAM,IAAI,KAAK,CAAC,+BAA+B,QAAQ,IAAI,IAAI,EAAE,CAAC,CAAC;IACvE,CAAC;AACH,CAAC;AAED,6DAA6D;AAC7D,MAAM,UAAU,SAAS;IACvB,MAAM,GAAG,GAAG,WAAW,EAAE,CAAC;IAC1B,MAAM,IAAI,GAAG,SAAS,GAAG,OAAO,CAAC;IAEjC,+DAA+D;IAC/D,KAAK,MAAM,SAAS,IAAI;QACtB,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC;QAChB,IAAI,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC;QACtB,IAAI,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,GAAG,EAAE,IAAI,CAAC;KACnC,EAAE,CAAC;QACF,IAAI,UAAU,CAAC,SAAS,CAAC;YAAE,OAAO,OAAO,CAAC,SAAS,CAAC,CAAC;IACvD,CAAC;IAED,qCAAqC;IACrC,IAAI,CAAC;QACH,OAAO,OAAO,CAAC,gBAAgB,GAAG,EAAE,CAAC,CAAC;IACxC,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,MAAM,IAAI,KAAK,CACb,8CAA8C,GAAG,KAAK;YACpD,0DAA0D,GAAG,sCAAsC;YACnG,UAAW,KAAe,CAAC,OAAO,EAAE,CACvC,CAAC;IACJ,CAAC;AACH,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { defineRule, loadProject, runLint, engineVersion, } from "./runtime.ts";
+export type { Severity, Diagnostic, SourceFile, AstNode, PrepareResult, Project, Finding, RuleSpec, RunOptions, JsonSchema, Ctx, AllowlistLoad, RawAllowlist, } from "./runtime.ts";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAaA,OAAO,EACL,UAAU,EACV,WAAW,EACX,OAAO,EACP,aAAa,GACd,MAAM,cAAc,CAAC;AAEtB,YAAY,EACV,QAAQ,EACR,UAAU,EACV,UAAU,EACV,OAAO,EACP,aAAa,EACb,OAAO,EACP,OAAO,EACP,QAAQ,EACR,UAAU,EAEV,UAAU,EACV,GAAG,EACH,aAAa,EACb,YAAY,GACb,MAAM,cAAc,CAAC"}

package/dist/index.js

@@ -0,0 +1,14 @@
+// index.ts — the dowel TS authoring API (plan 005 §2).
+//
+// The package's main entry. Consumers author rules against this surface:
+//   import { defineRule } from "@dowel/dowel";
+// It re-exports the rule-authoring primitives and every type a `check` touches.
+// The lint runner itself lives in `bin/dowel.mjs` (run via the `dowel` bin);
+// the lower-level engine driver is `@dowel/dowel/runtime`.
+//
+// NOTE (plan 004): when core-004 lands per-rule typed options + the allowlist
+// primitive, the `optionsSchema`/`ctx.options`/`ctx.loadAllowlist` types are
+// added to `RuleSpec`/the check context in runtime.ts and flow through this
+// re-export automatically — no separate surface needed here.
+export { defineRule, loadProject, runLint, engineVersion, } from "./runtime.js";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAAA,uDAAuD;AACvD,EAAE;AACF,yEAAyE;AACzE,+CAA+C;AAC/C,gFAAgF;AAChF,6EAA6E;AAC7E,2DAA2D;AAC3D,EAAE;AACF,8EAA8E;AAC9E,6EAA6E;AAC7E,4EAA4E;AAC5E,6DAA6D;AAE7D,OAAO,EACL,UAAU,EACV,WAAW,EACX,OAAO,EACP,aAAa,GACd,MAAM,cAAc,CAAC"}

package/dist/runtime.d.ts

@@ -0,0 +1,118 @@
+export type Severity = "error" | "warn";
+export interface Diagnostic {
+    rule: string;
+    severity: Severity;
+    file: string;
+    line: number;
+    message: string;
+}
+export interface SourceFile {
+    path: string;
+    relPath: string;
+    lang: string;
+    text: string;
+}
+export interface AstNode {
+    id: number;
+    kind: string;
+    kindId: number;
+    startByte: number;
+    endByte: number;
+    startRow: number;
+    endRow: number;
+    parent: number;
+    named: boolean;
+}
+export interface PrepareResult {
+    ok: boolean;
+    skipped: boolean;
+    error: string | null;
+    columns: {
+        name: string;
+        pgType: string;
+        tsType: string;
+        nullable: boolean;
+    }[];
+}
+/** Core's allowlist loader output: unnormalised tokens + `# reason` violations. */
+export interface RawAllowlist {
+    tokens: string[];
+    violations: Finding[];
+}
+/** The compiled project + engine primitives a rule's `check` is handed. */
+export interface Project {
+    root: string;
+    files(): SourceFile[];
+    read(rel: string): string | null;
+    glob(pattern: string): string[];
+    astOf(path: string): AstNode[];
+    /** Prepare SQL against the shadow DB — the SQL-drift signal. */
+    prepareSql(sql: string): PrepareResult;
+    /**
+     * Core's one allowlist loader (`arch_lint_core::allowlist::load_allowlist`):
+     * parses `token  # reason` lines, enforcing the reason convention. Tokens are
+     * returned as written; [`Ctx.loadAllowlist`] applies the rule's `normalize`.
+     */
+    loadAllowlistRaw(rel: string): RawAllowlist;
+}
+/** A diagnostic a rule emits (its `rule` id is filled in by the runner). */
+export type Finding = Omit<Diagnostic, "rule"> & {
+    rule?: string;
+};
+/**
+ * A minimal JSON-Schema subtree, enough to declare per-rule options and carry
+ * their defaults (plan 004 §2). Mirrors the `serde_json::Value` schemas core's
+ * native/declarative rules use, so a future `.d.ts` generator can share it.
+ */
+export interface JsonSchema {
+    type?: "object" | "array" | "string" | "number" | "integer" | "boolean";
+    properties?: Record<string, JsonSchema>;
+    items?: JsonSchema;
+    default?: unknown;
+    [k: string]: unknown;
+}
+/** The result of [`Ctx.loadAllowlist`] — exempt tokens + `# reason` violations. */
+export interface AllowlistLoad {
+    allow: Set<string>;
+    violations: Finding[];
+}
+/**
+ * The second argument to a rule's `check`. Carries the rule's validated options
+ * (schema defaults overlaid by the `[rules.<CODE>]` table) and the shared
+ * allowlist loader, so no rule re-implements config plumbing (plan 004).
+ */
+export interface Ctx<O = Record<string, unknown>> {
+    /** Validated options: `optionsSchema` defaults overlaid by `[rules.<CODE>]`. */
+    options: O;
+    /**
+     * Load a sidecar allowlist (`token  # reason` per line) by project-relative
+     * path. Enforces the `# reason` convention — a missing reason becomes a
+     * `violations` diagnostic (attributed to `violationRuleId`, else left for the
+     * runner to stamp with the calling rule's id). `normalize` canonicalises each
+     * token before it enters the `allow` set. Missing file ⇒ empty, no violations.
+     */
+    loadAllowlist(relPath: string, normalize?: (token: string) => string, violationRuleId?: string): AllowlistLoad;
+}
+export interface RuleSpec<O = Record<string, unknown>> {
+    id: string;
+    intent: string;
+    group?: string;
+    appliesTo?: string[];
+    /** Per-rule options schema; its property `default`s seed `ctx.options`. */
+    optionsSchema?: JsonSchema;
+    check(project: Project, ctx: Ctx<O>): Finding[];
+}
+export declare function defineRule<O = Record<string, unknown>>(spec: RuleSpec<O>): RuleSpec<O>;
+/** Load a project handle and return the wrapped, rule-facing `Project`. The
+ *  optional `rules` register their schemas so `[rules.<CODE>]` overrides resolve. */
+export declare function loadProject(root: string, configPath: string, withOracle: boolean, rules?: RuleSpec[]): Project;
+export interface RunOptions {
+    root: string;
+    configPath: string;
+    withOracle: boolean;
+    rules: RuleSpec[];
+}
+/** Run the native packs + every TS rule and return one merged, sorted stream. */
+export declare function runLint(opts: RunOptions): Diagnostic[];
+export declare const engineVersion: string;
+//# sourceMappingURL=runtime.d.ts.map

package/dist/runtime.d.ts.map

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

package/dist/runtime.js

@@ -0,0 +1,136 @@
+// runtime.ts — the TS-native rule tier for dowel (plan 003 §5c, plan 004, 005).
+//
+// Loads the compiled native addon (core's engine: Project, AST, shadow-DB
+// Oracle) and drives the lint loop in JS, so domain rules are authored in
+// TypeScript (`defineRule`) instead of a Rust rule-pack crate. The native rule
+// packs still run via `lintNative` — their diagnostics merge with the TS ones.
+//
+// This is the published copy of the runner (plan 005 §2): the body is kept
+// byte-for-byte identical to the consumer-side runtime.ts (the parity source of
+// truth, owned by the plan-004 bridge) EXCEPT the addon is resolved through the
+// platform-dispatch loader (binding.ts) instead of a hardcoded local `require`
+// — so a published @dowel/dowel-<triple> package is found.
+import { loadAddon } from "./binding.js";
+const addon = loadAddon();
+export function defineRule(spec) {
+    return spec;
+}
+/** Extract `{ key: default }` for every property declaring a `default`. */
+function schemaDefaults(schema) {
+    const out = {};
+    if (!schema?.properties)
+        return out;
+    for (const [key, prop] of Object.entries(schema.properties)) {
+        if (prop && "default" in prop)
+            out[key] = prop.default;
+    }
+    return out;
+}
+/**
+ * Resolve a rule's options: schema defaults overlaid by any `[rules.<CODE>]`
+ * table the engine parsed. `tableJson` is the raw table as JSON (`{}` if none),
+ * so until a consumer adds a table the result is exactly the schema defaults —
+ * i.e. today's hardcoded-constant behaviour, byte-for-byte.
+ */
+function resolveOptions(spec, tableJson) {
+    const defaults = schemaDefaults(spec.optionsSchema);
+    let table = {};
+    if (tableJson) {
+        try {
+            const parsed = JSON.parse(tableJson);
+            if (parsed && typeof parsed === "object")
+                table = parsed;
+        }
+        catch {
+            // A malformed table is the engine's problem; defaults keep the rule running.
+        }
+    }
+    return { ...defaults, ...table };
+}
+/**
+ * Build a rule's `ctx`. The allowlist loader delegates to core's single
+ * `arch_lint_core::allowlist::load_allowlist` (via the addon) — the `# reason`
+ * parse and canonical message live in Rust, shared by every tier. The bridge
+ * only applies the rule's `normalize` to the returned tokens and stamps the
+ * violation `rule` id (a shared-allowlist rule passes `violationRuleId`).
+ */
+function makeCtx(project, options) {
+    return {
+        options,
+        loadAllowlist(relPath, normalize, violationRuleId) {
+            const { tokens, violations } = project.loadAllowlistRaw(relPath);
+            const allow = new Set(tokens.map((t) => (normalize ? normalize(t) : t)));
+            const stamped = violationRuleId
+                ? violations.map((v) => ({ ...v, rule: violationRuleId }))
+                : violations;
+            return { allow, violations: stamped };
+        },
+    };
+}
+function wrap(h) {
+    return {
+        root: h.root(),
+        files: () => h.files(),
+        read: (rel) => h.read(rel),
+        glob: (pattern) => h.glob(pattern),
+        astOf: (path) => h.astOf(path),
+        prepareSql: (sql) => h.oraclePrepare(sql),
+        loadAllowlistRaw: (rel) => {
+            const r = h.loadAllowlist(rel);
+            // Drop core's placeholder `rule`; the ctx caller stamps attribution.
+            const violations = r.violations.map((v) => ({
+                severity: v.severity,
+                file: v.file,
+                line: v.line,
+                message: v.message,
+            }));
+            return { tokens: r.tokens, violations };
+        },
+    };
+}
+/**
+ * Serialise the TS rules' `optionsSchema`s as `[{ code, schema }]` so the engine
+ * treats each TS-tier code as a first-class rule when validating `[rules.<CODE>]`
+ * tables — without this a consumer override of a TS rule's option is rejected as
+ * an unknown code. Rules with no schema are omitted (no options to resolve).
+ */
+function tsSchemasJson(rules) {
+    return JSON.stringify(rules.filter((r) => r.optionsSchema).map((r) => ({ code: r.id, schema: r.optionsSchema })));
+}
+/** Load a project handle and return the wrapped, rule-facing `Project`. The
+ *  optional `rules` register their schemas so `[rules.<CODE>]` overrides resolve. */
+export function loadProject(root, configPath, withOracle, rules = []) {
+    return wrap(addon.ProjectHandle.load(root, configPath, withOracle, tsSchemasJson(rules)));
+}
+/** Run the native packs + every TS rule and return one merged, sorted stream. */
+export function runLint(opts) {
+    const tsSchemas = tsSchemasJson(opts.rules);
+    const handle = addon.ProjectHandle.load(opts.root, opts.configPath, opts.withOracle, tsSchemas);
+    const project = wrap(handle);
+    const native = addon.lintNative(opts.root, opts.configPath, opts.withOracle, tsSchemas);
+    const ts = [];
+    for (const rule of opts.rules) {
+        const tableJson = handle.ruleOptions(rule.id);
+        const ctx = makeCtx(project, resolveOptions(rule, tableJson));
+        let found;
+        try {
+            found = rule.check(project, ctx) ?? [];
+        }
+        catch (e) {
+            // Panic isolation: a throwing rule becomes one diagnostic, not a crash.
+            ts.push({
+                rule: rule.id,
+                severity: "error",
+                file: "",
+                line: 0,
+                message: `rule '${rule.id}' threw: ${e.message}`,
+            });
+            continue;
+        }
+        for (const f of found)
+            ts.push({ ...f, rule: f.rule ?? rule.id });
+    }
+    return [...native, ...ts].sort((a, b) => a.file.localeCompare(b.file) || a.line - b.line || a.rule.localeCompare(b.rule));
+}
+export const engineVersion = addon.version();
+//# sourceMappingURL=runtime.js.map

package/dist/runtime.js.map

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

package/package.json

@@ -1,12 +1,71 @@
 {
   "name": "@dowel/dowel",
-  "version": "0.0.1",
-  "description": "An opinionated, compiled architecture linter. Name placeholder — real release coming soon.",
-  "license": "MIT OR Apache-2.0",
+  "version": "0.1.0",
+  "description": "dowel — a compiled, opinionated architecture linter. TS-native rule authoring over a Rust engine (Project, AST, shadow-DB SQL oracle).",
+  "license": "MIT",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/swiftcomza/arch-lint.git"
   },
-  "keywords": ["linter", "architecture", "static-analysis"],
-  "files": ["README.md"]
-}
+  "type": "module",
+  "bin": {
+    "dowel": "./bin/dowel.mjs"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./runtime": {
+      "types": "./dist/runtime.d.ts",
+      "default": "./dist/runtime.js"
+    }
+  },
+  "files": [
+    "dist/",
+    "bin/",
+    "README.md",
+    "LICENSE"
+  ],
+  "napi": {
+    "binaryName": "dowel",
+    "packageName": "@dowel/dowel",
+    "targets": [
+      "aarch64-apple-darwin",
+      "x86_64-apple-darwin",
+      "x86_64-unknown-linux-gnu",
+      "aarch64-unknown-linux-gnu",
+      "x86_64-unknown-linux-musl",
+      "x86_64-pc-windows-msvc"
+    ]
+  },
+  "engines": {
+    "node": ">= 20"
+  },
+  "scripts": {
+    "build": "napi build --platform --release --manifest-path Cargo.toml && tsc -p tsconfig.json",
+    "build:debug": "napi build --platform --manifest-path Cargo.toml && tsc -p tsconfig.json",
+    "build:ts": "tsc -p tsconfig.json",
+    "artifacts": "napi artifacts",
+    "create-npm-dirs": "napi create-npm-dirs",
+    "prepublishOnly": "napi prepublish -t npm"
+  },
+  "devDependencies": {
+    "@napi-rs/cli": "^3.0.0",
+    "typescript": "^5.6.0",
+    "@types/node": "^22.0.0"
+  },
+  "optionalDependencies": {
+    "@dowel/dowel-darwin-arm64": "0.1.0",
+    "@dowel/dowel-darwin-x64": "0.1.0",
+    "@dowel/dowel-linux-x64-gnu": "0.1.0",
+    "@dowel/dowel-linux-arm64-gnu": "0.1.0",
+    "@dowel/dowel-linux-x64-musl": "0.1.0",
+    "@dowel/dowel-win32-x64-msvc": "0.1.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}