@vibgrate/haile 2026.902.1

package/LICENSE

@@ -0,0 +1,43 @@
+Vibgrate HAILE Architecture Kernel — Proprietary License
+SPDX-License-Identifier: LicenseRef-Vibgrate-Proprietary
+Copyright (c) 2026 Vibgrate. All rights reserved.
+
+This package ("@vibgrate/haile") distributes the Vibgrate HAILE architecture
+kernel — deterministic callable classification (role distribution, multi-label
+purposes, intent templates, confidence bands) — as a compiled artifact. It is
+proprietary and confidential, and is licensed SEPARATELY from — and is NOT
+covered by — the Apache-2.0 license that applies to @vibgrate/cli,
+@vibgrate/core-open, or any other open component.
+
+1. DEFINITIONS
+   "Distributed Artifact" means the compiled JavaScript/TypeScript module(s)
+   and any compiled WebAssembly module shipped in this package. The underlying
+   source, taxonomy, and kernel build tooling are NOT part of this package and
+   are not distributed.
+
+2. GRANT (EXECUTION)
+   Subject to a valid Vibgrate license or subscription, Vibgrate grants you a
+   non-exclusive, non-transferable, revocable right to EXECUTE the Distributed
+   Artifact as an optional module of the Vibgrate CLI, on any machine you
+   control — including air-gapped and customer-premises environments. Analysis
+   runs locally; source never leaves the client.
+
+3. RESTRICTIONS
+   You may NOT, in whole or in part: (a) copy, redistribute, sublicense, sell,
+   or publish the Distributed Artifact outside an authorized Vibgrate CLI
+   distribution; (b) reverse-engineer, decompile, disassemble, or otherwise
+   attempt to derive the source of, or the taxonomy and calibration within,
+   the Distributed Artifact, except to the extent this restriction is
+   unenforceable under applicable law; (c) create derivative works; (d) remove
+   or alter this notice.
+
+4. NO OPEN-SOURCE GRANT
+   Nothing in this repository's Apache-2.0 license, NOTICE, or any other open
+   license extends to this package.
+
+5. NO WARRANTY
+   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+   IMPLIED. TO THE MAXIMUM EXTENT PERMITTED BY LAW, VIBGRATE DISCLAIMS ALL
+   LIABILITY ARISING FROM ITS USE.
+
+For licensing inquiries: legal@vibgrate.com

package/README.md

@@ -0,0 +1,65 @@
+# @vibgrate/haile
+
+The Vibgrate HAILE architecture kernel: deterministic classification of
+callables (role distribution, multi-label purposes, intent, confidence band)
+over a `vg-graph/1.x` document. Consumed by the Vibgrate CLI's optional HAILE
+seam (`engine/haile/haile-provider.ts` and `engine/haile/sidecar.ts` in
+`@vibgrate/cli`).
+
+This package is a **binary-only, proprietary** distribution: it ships a
+compiled loader plus the embedded WASM engine — **never the taxonomy or the
+kernel source**. Classification runs entirely locally (incl. air-gapped);
+source never leaves the machine.
+
+> The kernel source is the Rust crate in `crate/` (this private monorepo only)
+> and is **not** part of this package — only its compiled `.wasm` ships.
+> `engine/README.md` documents the build, the drop slot, and the C ABI. A
+> published tarball without `dist/engine/haile.wasm` is refused.
+
+## API
+
+```ts
+import { createHaileProvider } from "@vibgrate/haile";
+
+const kernel = createHaileProvider();
+// null when dist/engine/haile.wasm is missing — never a dummy provider.
+kernel?.version();
+// "haile-fast/0.1.1" (or the version string the wasm exports)
+kernel?.classify({
+  name: "CreateUser",
+  path: "src/controllers/UsersController.cs",
+  symbolKind: "method",
+  profile: "balanced",
+});
+// { primary, confidence, band, alternatives, purposes, intent, evidence }
+```
+
+The host CLI auto-provisions this module (silently, on every run; declinable)
+and loads it through its generic provider seam (default module path or
+`VIBGRATE_HAILE_PATH`), sanitises every result at its own trust boundary, and
+omits architecture lines when the module is absent or `VIBGRATE_NO_KERNEL=1`
+is set. It never falls back to a TypeScript lexicon.
+
+## Sidecar CLI
+
+The published `dist/index.js` is also the process the CLI launches:
+
+```bash
+node index.js sidecar --stdin --out graph.haile.json --profile balanced < graph.json
+```
+
+- stdin: a full `vg-graph/1.x` JSON document
+- `--out`: destination classify file (`graph.haile.json`)
+- `--profile`: `strict` \| `balanced` \| `exploratory`
+- wire: `magic=vg.haile.v1`, `taxonomy=haile.taxonomy.v1`, `ir=haile.ir.v1`, snake_case
+- missing wasm, bad args, or a write failure → exit code 1 (the CLI treats that as "do not write / do not use")
+
+## Build (maintainers)
+
+```bash
+rustup target add wasm32-unknown-unknown            # once
+pnpm --filter @vibgrate/haile build                 # tsup + esbuild + cargo → dist/ (wasm vendored)
+VG_HAILE_RELEASE=1 pnpm --filter @vibgrate/haile build  # refuses without wasm
+pnpm --filter @vibgrate/haile test                  # loader ↔ kernel contract (kernel cases need the wasm)
+(cd crate && cargo test)                            # kernel unit tests, native
+```

package/dist/index.d.ts

@@ -0,0 +1,118 @@
+/** Public loader types. Mirror the CLI seam in engine/haile/haile-provider.ts. */
+type HaileProfile = "strict" | "balanced" | "exploratory";
+interface HaileClassifyInput {
+    name: string;
+    path: string;
+    symbolKind?: string;
+    fileKind?: string;
+    calls?: readonly string[];
+    types?: readonly string[];
+    idents?: readonly string[];
+    profile?: HaileProfile;
+}
+interface HaileClassification {
+    primary: string;
+    confidence: number;
+    band: string;
+    alternatives: {
+        role: string;
+        confidence: number;
+    }[];
+    purposes: {
+        purpose: string;
+        confidence: number;
+    }[];
+    intent: {
+        text: string;
+        verbs: string[];
+        objects: string[];
+    };
+    evidence: {
+        kind: string;
+        signal: string;
+        weight: number;
+    }[];
+}
+interface HaileProvider {
+    version(): string;
+    classify(input: HaileClassifyInput): HaileClassification | null;
+}
+/** Wire constants for graph.haile.json. Frozen with the public CLI. */
+declare const HAILE_MAGIC = "vg.haile.v1";
+declare const HAILE_TAXONOMY = "haile.taxonomy.v1";
+declare const HAILE_IR = "haile.ir.v1";
+declare const HAILE_ENGINE_VERSION = "haile-fast/0.1.1";
+declare const DEFAULT_PROFILE: HaileProfile;
+declare const DEFAULT_SYMBOL_CAP = 8000;
+
+interface WasmHaileKernel {
+    version(): string;
+    classifyJson(input: HaileClassifyInput): string;
+}
+/** Load the wasm engine if the artifact exists; null otherwise. Memoized. */
+declare function loadWasmHaileKernel(): WasmHaileKernel | null;
+/** Reset the memoized engine (tests only). */
+declare function resetWasmHaileKernelCache(): void;
+
+/**
+ * Factory consumed by the public CLI seam (loadHaileProvider).
+ *
+ * Returns null when the wasm engine is missing — never a dummy provider,
+ * never a TypeScript lexicon. The host then refuses to write classify output.
+ */
+
+declare function createHaileProvider(kernel?: WasmHaileKernel | null): HaileProvider | null;
+
+/**
+ * Map a vg-graph/1.x document onto HAILE callables.
+ *
+ * Structural only — same callable-kind set as the public CLI adapter.
+ * Does not classify, does not re-parse, contains no lexicon.
+ */
+interface GraphNodeLike {
+    id: string;
+    kind: string;
+    name: string;
+    qualifiedName?: string;
+    file: string;
+    lang?: string;
+    signature?: string;
+}
+interface GraphEdgeLike {
+    kind: string;
+    src: string;
+    dst: string;
+}
+interface HaileCallable {
+    node_id: string;
+    file_path: string;
+    name: string;
+    qualified_name: string;
+    symbol_kind: string;
+    language: string;
+    signature: string;
+    calls: string[];
+    parameters: Array<{
+        name: string;
+        type_name?: string;
+    }>;
+    return_type?: string;
+    file_layer?: string;
+    ast_role?: string;
+}
+declare function isCallableKind(kind: string): boolean;
+declare function symbolKindOf(kind: string): string;
+declare function adaptGraph(graph: {
+    nodes?: GraphNodeLike[];
+    edges?: GraphEdgeLike[];
+}): HaileCallable[];
+
+interface SidecarDeps {
+    /** Kernel provider; `undefined` loads the wasm engine, `null` forces the absent state. */
+    provider?: HaileProvider | null;
+    /** Source of the vg-graph JSON text (defaults to process.stdin). */
+    readInput?: () => Promise<string>;
+}
+declare function runSidecarCli(argv?: string[], deps?: SidecarDeps): Promise<number>;
+
+export { DEFAULT_PROFILE, DEFAULT_SYMBOL_CAP, HAILE_ENGINE_VERSION, HAILE_IR, HAILE_MAGIC, HAILE_TAXONOMY, type HaileClassification, type HaileClassifyInput, type HaileProfile, type HaileProvider, type SidecarDeps, adaptGraph, createHaileProvider, isCallableKind, loadWasmHaileKernel, resetWasmHaileKernelCache, runSidecarCli, symbolKindOf };

package/dist/index.js

@@ -0,0 +1,10 @@
+import{pathToFileURL as j}from"node:url";import*as u from"node:fs";import*as g from"node:path";var b="vg.haile.v1",_="haile.taxonomy.v1",h="haile.ir.v1",v="haile-fast/0.1.1",w="balanced",H=8e3,k=new Set(["function","method","route","test","component","job"]);function C(n){return k.has(n)}function P(n){switch(n){case"method":return"method";case"route":return"route";case"test":return"test";case"job":return"job";case"component":return"handler";default:return"function"}}function N(n){let r=n.indexOf("("),s=n.lastIndexOf(")");if(r<0||s<=r)return[];let i=n.slice(r+1,s).trim();return!i||i==="void"?[]:i.split(",").map(a=>a.trim()).filter(Boolean).slice(0,16).map(a=>{let e=a.replace(/\b(const|mut|ref|public|private|protected|readonly|final)\b/g,"").trim();if(e.includes(":")){let[l,c]=e.split(":").map(d=>d.trim());return{name:l||"arg",type_name:c||void 0}}let t=e.split(/\s+/);return t.length>=2?{name:t[t.length-1],type_name:t[0]}:{name:e}})}function R(n){let r=n.lastIndexOf("->");if(r>=0)return n.slice(r+2).replace(/[{;].*$/,"").trim()||void 0;let s=n.lastIndexOf(":"),i=n.lastIndexOf(")");if(s>i&&i>=0)return n.slice(s+1).replace(/[{;=>].*$/,"").trim()||void 0}function T(n,r,s){let i=[],a=new Set;for(let e of r){if(e.src!==n||e.kind!=="call"&&e.kind!=="references")continue;let t=s.get(e.dst);if(!(!t||a.has(t))&&(a.add(t),i.push(t),i.length>=24))break}return i}function x(n){let r=n.nodes??[],s=n.edges??[],i=new Map;for(let e of r)i.set(e.id,e.name);let a=[];for(let e of r){if(!C(e.kind))continue;let t=e.signature??"";a.push({node_id:e.id,file_path:e.file,name:e.name,qualified_name:e.qualifiedName||e.name,symbol_kind:P(e.kind),language:e.lang??"",signature:t,calls:T(e.id,s,i),parameters:N(t),return_type:R(t)})}return a.sort((e,t)=>e.node_id<t.node_id?-1:e.node_id>t.node_id?1:0),a}import*as m from"node:fs";import{fileURLToPath as F}from"node:url";var f;function G(){return[new URL("./engine/haile.wasm",import.meta.url),new URL("../engine/haile.wasm",import.meta.url),new URL("../crate/target/wasm32-unknown-unknown/release/vibgrate_haile_kernel.wasm",import.meta.url)].map(n=>F(n))}function A(){if(f!==void 0)return f;f=null;try{let n=G().find(t=>m.existsSync(t));if(!n)return f;let r=new WebAssembly.Module(m.readFileSync(n)),i=new WebAssembly.Instance(r,{}).exports;if(typeof i.vg_alloc!="function"||typeof i.vg_free!="function"||typeof i.vg_version!="function"||typeof i.vg_classify!="function"||!i.memory)return f;let a=t=>{let l=new TextEncoder().encode(t),c=i.vg_alloc(l.length);return new Uint8Array(i.memory.buffer,c,l.length).set(l),{ptr:c,len:l.length}},e=t=>{if(!t)return"";let l=new DataView(i.memory.buffer,t,4).getUint32(0,!0),c=new TextDecoder().decode(new Uint8Array(i.memory.buffer,t+4,l));return i.vg_free(t,4+l),c};return f={version:()=>{try{return e(i.vg_version())||"haile-fast/0.1.1"}catch{return"haile-fast/0.1.1"}},classifyJson:t=>{let l=JSON.stringify({name:t.name??"",path:t.path??"",symbolKind:t.symbolKind??"function",fileKind:t.fileKind??"source",calls:t.calls??[],types:t.types??[],idents:t.idents??[],profile:t.profile??"balanced"}),{ptr:c,len:d}=a(l);try{return e(i.vg_classify(c,d))}finally{i.vg_free(c,d)}}},f}catch{return f=null,f}}function M(){f=void 0}function S(n){return Array.isArray(n)?n.filter(r=>typeof r=="string"):[]}function U(n){if(!n)return null;try{let r=JSON.parse(n);if(!r||typeof r!="object")return null;let s=r.role&&typeof r.role=="object"?r.role:r,i=typeof s.primary=="string"?s.primary:"";if(!i)return null;let a=r.intent&&typeof r.intent=="object"?r.intent:{};return{primary:i,confidence:typeof s.confidence=="number"?s.confidence:0,band:typeof s.band=="string"?s.band:"abstain",alternatives:Array.isArray(s.alternatives)?s.alternatives.filter(e=>typeof e?.role=="string").map(e=>({role:e.role,confidence:typeof e.confidence=="number"?e.confidence:0})):[],purposes:Array.isArray(r.purposes)?r.purposes.filter(e=>typeof e?.purpose=="string").map(e=>({purpose:e.purpose,confidence:typeof e.confidence=="number"?e.confidence:0})):[],intent:{text:typeof a.text=="string"?a.text:"",verbs:S(a.verbs),objects:S(a.objects)},evidence:Array.isArray(r.evidence)?r.evidence.filter(e=>typeof e?.kind=="string"&&typeof e?.signal=="string").map(e=>({kind:e.kind,signal:e.signal,weight:typeof e.weight=="number"?e.weight:0})):[]}}catch{return null}}function I(n){let r=n===void 0?A():n;return r?{version:()=>r.version(),classify:s=>{try{return U(r.classifyJson(s))}catch{return null}}}:null}var D=new Set(["strict","balanced","exploratory"]);function O(n,r){let s=n.indexOf(r);if(!(s<0||s+1>=n.length))return n[s+1]}function W(){return new Promise((n,r)=>{let s=[];process.stdin.on("data",i=>s.push(Buffer.from(i))),process.stdin.on("end",()=>n(Buffer.concat(s).toString("utf8"))),process.stdin.on("error",r)})}async function L(n=process.argv.slice(2),r={}){if(n[0]!=="sidecar")return process.stderr.write(`usage: node index.js sidecar --stdin --out <file> --profile <strict|balanced|exploratory>
+`),1;if(!n.includes("--stdin"))return process.stderr.write(`sidecar requires --stdin
+`),1;let s=O(n,"--out");if(!s)return process.stderr.write(`sidecar requires --out <file>
+`),1;let i=O(n,"--profile")??w;if(!D.has(i))return process.stderr.write(`invalid --profile ${i}
+`),1;let a=i,e=r.provider===void 0?I():r.provider;if(!e)return process.stderr.write(`architecture kernel wasm missing \u2014 refusing to classify
+`),1;let t;try{let o=(await(r.readInput??W)()).trim();if(!o)return process.stderr.write(`sidecar stdin was empty
+`),1;t=JSON.parse(o)}catch{return process.stderr.write(`sidecar stdin was not valid JSON
+`),1}let l=x({nodes:Array.isArray(t.nodes)?t.nodes:[],edges:Array.isArray(t.edges)?t.edges:[]}),c=e.version()||v,d=[],E=!1;for(let o of l){if(d.length>=8e3){E=!0;break}let p=e.classify({name:o.name,path:o.file_path,symbolKind:o.symbol_kind,fileKind:"source",calls:o.calls,types:[...o.parameters.map(y=>y.type_name).filter(y=>!!y),...o.return_type?[o.return_type]:[]],idents:[o.name,...o.calls].slice(0,24),profile:a});p&&d.push({node_id:o.node_id,file_path:o.file_path,name:o.name,qualified_name:o.qualified_name,symbol_kind:o.symbol_kind,role:{primary:p.primary,alternatives:p.alternatives,confidence:p.confidence,band:p.band},purposes:p.purposes,intent:p.intent,evidence:p.evidence})}let K={magic:b,taxonomy:_,ir:h,corpus_hash:t.provenance?.corpusHash??"",engine_version:c,profile:a,symbols:d,...E?{symbols_capped:!0}:{}};try{u.mkdirSync(g.dirname(g.resolve(s)),{recursive:!0});let o=`${s}.${process.pid}.tmp`;u.writeFileSync(o,`${JSON.stringify(K)}
+`),u.renameSync(o,s)}catch{return process.stderr.write(`sidecar failed to write ${s}
+`),1}return 0}function B(){let n=process.argv[1];if(!n)return!1;try{return import.meta.url===j(n).href}catch{return!1}}B()&&L().then(n=>{process.exit(n)});export{w as DEFAULT_PROFILE,H as DEFAULT_SYMBOL_CAP,v as HAILE_ENGINE_VERSION,h as HAILE_IR,b as HAILE_MAGIC,_ as HAILE_TAXONOMY,x as adaptGraph,I as createHaileProvider,C as isCallableKind,A as loadWasmHaileKernel,M as resetWasmHaileKernelCache,L as runSidecarCli,P as symbolKindOf};

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@vibgrate/haile",
+  "version": "2026.902.1",
+  "description": "Vibgrate HAILE architecture kernel: deterministic callable classification (role, purposes, intent, band) over a vg-graph. Proprietary distribution — compiled WASM engine plus a minified loader; the taxonomy is not included.",
+  "license": "SEE LICENSE IN LICENSE",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "node build.mjs",
+    "typecheck": "tsc --noEmit -p ./",
+    "test": "vitest run"
+  },
+  "devDependencies": {
+    "@types/node": "^26.2.0",
+    "esbuild": "^0.25.12",
+    "tsup": "^8.0.0",
+    "typescript": "^5.4.0",
+    "vitest": "^4.1.10"
+  },
+  "engines": {
+    "node": ">=22.0.0"
+  }
+}