zeropoint-node 1.0.1 → 1.0.3

package/src/kernel/import-graph.ts

@@ -0,0 +1,237 @@
+/**
+ * Computed import/export self-reference fold.
+ *
+ * Scans `a432.*` under `src/` → builds the import/export edge graph →
+ * content-uuid + merkleFold census. Addresses are computed, never hand-inventoried.
+ *
+ * memoByRoot / one merkle walk = trinity speedup. vortexInvariantsHold = computeVortexInvariantsHold()
+ * (structural seals).
+ */
+
+import { readdirSync, readFileSync, statSync } from 'node:fs'
+import { join, relative, resolve, dirname, extname } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import {
+  computeVortexInvariantsHold,
+  computesGate,
+  foldPair,
+  memoByRoot,
+  merge,
+  merkleFold,
+  toUuid,
+} from '../0/index.ts'
+import { computeContentUuid } from '../integrity/content-uuid.ts'
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+export const SRC_ROOT = resolve(__dirname, '..')
+
+const IMPORT_RE =
+  /(?:import|export)\s+(?:type\s+)?(?:[\s\S]*?\s+from\s+)?['"]([^'"]+)['"]/g
+const EXPORT_NAMED_RE = /export\s+(?:async\s+)?(?:function|const|class|type|interface|enum)\s+([A-Za-z0-9_$]+)/g
+const EXPORT_LIST_RE = /export\s*\{([^}]+)\}/g
+
+export type GraphNode = {
+  readonly path: string
+  readonly contentUuid: string
+  readonly softUuid: string
+  readonly imports: readonly string[]
+  readonly exports: readonly string[]
+}
+
+export type GraphEdge = {
+  readonly from: string
+  readonly to: string
+  readonly receipt: string
+}
+
+export type ImportExportCensus = {
+  readonly computes: boolean
+  readonly fileCount: number
+  readonly edgeCount: number
+  readonly exportCount: number
+  readonly nodes: readonly GraphNode[]
+  readonly edges: readonly GraphEdge[]
+  readonly exportMap: Readonly<Record<string, readonly string[]>>
+  readonly importMap: Readonly<Record<string, readonly string[]>>
+  readonly root: string
+  readonly contentRoot: string
+  readonly statement: string
+  readonly boundary: string
+  readonly vortexInvariantsHold: boolean
+}
+
+function isA432Source(name: string): boolean {
+  return /^a432\./i.test(name) && (name.endsWith('.ts') || name.endsWith('.js'))
+}
+
+function walkA432Files(dir: string, out: string[] = []): string[] {
+  let entries: string[]
+  try {
+    entries = readdirSync(dir)
+  } catch {
+    return out
+  }
+  for (const name of entries) {
+    if (name === 'node_modules' || name === 'dist' || name.startsWith('.')) continue
+    const full = join(dir, name)
+    let st
+    try {
+      st = statSync(full)
+    } catch {
+      continue
+    }
+    if (st.isDirectory()) walkA432Files(full, out)
+    else if (st.isFile() && isA432Source(name)) out.push(full)
+  }
+  return out
+}
+
+function resolveImport(fromFile: string, spec: string): string | null {
+  if (spec.startsWith('node:') || (!spec.startsWith('.') && !spec.startsWith('/'))) {
+    return `ext:${spec}`
+  }
+  const base = resolve(dirname(fromFile), spec)
+  const candidates = [
+    base,
+    `${base}.ts`,
+    `${base}.js`,
+    join(base, 'index.ts'),
+    join(base, 'index.js'),
+  ]
+  for (const c of candidates) {
+    try {
+      if (statSync(c).isFile()) return relative(SRC_ROOT, c).replace(/\\/g, '/')
+    } catch {
+      /* try next */
+    }
+  }
+  return relative(SRC_ROOT, base).replace(/\\/g, '/')
+}
+
+function parseExports(source: string): string[] {
+  const names = new Set<string>()
+  for (const m of source.matchAll(EXPORT_NAMED_RE)) names.add(m[1]!)
+  for (const m of source.matchAll(EXPORT_LIST_RE)) {
+    for (const part of m[1]!.split(',')) {
+      const cleaned = part.trim()
+      if (!cleaned) continue
+      const asMatch = cleaned.match(/^(?:type\s+)?(\S+)\s+as\s+(\S+)$/)
+      if (asMatch) names.add(asMatch[2]!)
+      else names.add(cleaned.replace(/^type\s+/, '').split(/\s+/)[0]!)
+    }
+  }
+  if (/\bexport\s+default\b/.test(source)) names.add('default')
+  return [...names].sort()
+}
+
+function parseImports(fromFile: string, source: string): string[] {
+  const specs = new Set<string>()
+  for (const m of source.matchAll(IMPORT_RE)) {
+    const resolved = resolveImport(fromFile, m[1]!)
+    if (resolved) specs.add(resolved)
+  }
+  return [...specs].sort()
+}
+
+function rel(path: string): string {
+  return relative(SRC_ROOT, path).replace(/\\/g, '/')
+}
+
+/** Scan a432.* sources and fold the import/export graph into one census. */
+export function foldA432ImportExportGraph(srcRoot: string = SRC_ROOT): ImportExportCensus {
+  const matrix = { root: toUuid(`import-graph:${srcRoot}`) }
+  return memoByRoot('a432-import-export-graph', matrix, () => {
+    const files = walkA432Files(srcRoot).sort()
+    const nodes: GraphNode[] = files.map((file) => {
+      const source = readFileSync(file, 'utf8')
+      const path = rel(file)
+      const imports = parseImports(file, source)
+      const exports = parseExports(source)
+      const softUuid = toUuid(`a432-file:${path}`)
+      const contentUuid = computeContentUuid({
+        kind: 'a432-source',
+        path,
+        imports,
+        exports,
+        bytes: source.length,
+      })
+      return { path, contentUuid, softUuid, imports, exports }
+    })
+
+    const byPath = new Map(nodes.map((n) => [n.path, n]))
+    const edges: GraphEdge[] = []
+    for (const node of nodes) {
+      for (const target of node.imports) {
+        if (!byPath.has(target) && !target.startsWith('ext:')) continue
+        const to = byPath.has(target) ? target : target
+        edges.push({
+          from: node.path,
+          to,
+          receipt: merge(node.softUuid, toUuid(`edge:${to}`)),
+        })
+      }
+    }
+
+    const exportMap: Record<string, readonly string[]> = {}
+    const importMap: Record<string, readonly string[]> = {}
+    for (const n of nodes) {
+      exportMap[n.path] = n.exports
+      importMap[n.path] = n.imports
+    }
+
+    const exportCount = nodes.reduce((a, n) => a + n.exports.length, 0)
+    const nodeLeaves = nodes.map((n) => merge(n.softUuid, n.contentUuid))
+    const edgeLeaves = edges.map((e) => e.receipt)
+    const softRoot = merkleFold([...nodeLeaves, ...edgeLeaves])
+    const contentRoot = computeContentUuid({
+      kind: 'a432-import-export-census',
+      fileCount: nodes.length,
+      edgeCount: edges.length,
+      exportCount,
+      softRoot,
+    })
+    const throat = foldPair(softRoot, contentRoot)
+    const vortexInvariantsHold = computeVortexInvariantsHold()
+    const sealed = computesGate('a432-import-export-graph', [
+      { facet: 'scanned a432 sources', on: nodes.length > 0 },
+      { facet: 'export map keyed by path', on: Object.keys(exportMap).length === nodes.length },
+      { facet: 'merkle soft root', on: softRoot.length === 36 },
+      { facet: 'content root', on: contentRoot.length === 36 },
+      { facet: 'throat bidirectional', on: throat.bidirectional },
+      { facet: 'vortexInvariantsHold boolean', on: vortexInvariantsHold === true || vortexInvariantsHold === false },
+    ])
+
+    return {
+      computes: sealed.computes,
+      fileCount: nodes.length,
+      edgeCount: edges.length,
+      exportCount,
+      nodes,
+      edges,
+      exportMap,
+      importMap,
+      root: merkleFold([sealed.root, throat.merged, softRoot, contentRoot, toUuid(`ftl:${vortexInvariantsHold}`)]),
+      contentRoot,
+      statement:
+        'a432.* import/export graph is self-referencing by computation: content-uuid + merkleFold, not a hand inventory.',
+      boundary:
+        'memoByRoot / one merkle walk. vortexInvariantsHold=computeVortexInvariantsHold().',
+      vortexInvariantsHold,
+    }
+  })
+}
+
+/** Compact tip for gates / MCP — no giant node dump. */
+export function importExportGraphTip(srcRoot: string = SRC_ROOT) {
+  const g = foldA432ImportExportGraph(srcRoot)
+  return {
+    computes: g.computes,
+    fileCount: g.fileCount,
+    edgeCount: g.edgeCount,
+    exportCount: g.exportCount,
+    root: g.root,
+    contentRoot: g.contentRoot,
+    vortexInvariantsHold: g.vortexInvariantsHold,
+    statement: g.statement,
+  }
+}

package/src/kernel/index.ts

@@ -0,0 +1,78 @@
+/**
+ * Kernel barrel — double-torus development entry.
+ * Lobe L (ceccec) + Lobe R (erpax) feed through src/0.
+ */
+
+export * from '../0/index.ts'
+export * from './legacy.ts'
+export {
+  computeContentUuid,
+  computeContentDigest,
+  contentUuidOf,
+  verifyContentUuid,
+  jcsCanonicalize,
+  foldIntegrityReceipt,
+  ZEROPOINT_NAMESPACE_ROOT,
+} from '../integrity/content-uuid.ts'
+export {
+  appendReceipt,
+  computeReceiptId,
+  receiptPrevId,
+  verifyReceiptLink,
+  verifyReceiptChain,
+  GENESIS_PREV,
+} from '../integrity/receipt.ts'
+export type { Receipt, ReceiptChainVerify } from '../integrity/receipt.ts'
+export {
+  foldA432ImportExportGraph,
+  importExportGraphTip,
+  SRC_ROOT,
+} from './import-graph.ts'
+export type { ImportExportCensus, GraphNode, GraphEdge } from './import-graph.ts'
+export { foldA432AuditCensus, auditTip, A432_DIR } from './audit.ts'
+export { readLobe, readDoubleTorus } from './lobes.ts'
+export type { LobeName, LobeReading, LobeSurface, DoubleTorusReading } from './lobes.ts'
+export type { AuditCensus, AuditHit } from './audit.ts'
+export {
+  planTrinity,
+  selfBuild,
+  nextSelfDevelopTip,
+  tipFormOf,
+  isPreciseTip,
+  gateTipForm,
+  VAGUE_TIP_RE,
+  CONCRETE_CODE_RE,
+  CONCRETE_PROOF_RE,
+} from './self-develop.ts'
+export type {
+  PlanTrinity,
+  SelfDevelopTip,
+  SelfBuildStatus,
+  TipForm,
+  TipFormGate,
+} from './self-develop.ts'
+
+import { developmentVortex, foldPair, merkleFold, toUuid, WAVE_CHAIN } from '../0/index.ts'
+import { foldIntegrityReceipt } from '../integrity/content-uuid.ts'
+
+/** Run all wave tips through the development vortex; each feeds the next. */
+export function runDevelopmentVortexAll() {
+  const waves = WAVE_CHAIN.map((wave) => developmentVortex(wave))
+  const roots = waves.map((w) => w.root)
+  const chain = roots.reduce((prev, root, i) => {
+    if (i === 0) return root
+    return foldPair(prev, root).merged
+  }, toUuid('development-vortex:start'))
+  const integrity = foldIntegrityReceipt('development-vortex-all', {
+    waves: WAVE_CHAIN.slice(),
+    roots,
+  })
+  return {
+    waves,
+    chain,
+    integrity,
+    root: merkleFold([chain, integrity, ...roots]),
+    ok: waves.every((w) => w.computes),
+    statement: 'All chat waves feed each other in the double-torus development vortex.',
+  }
+}

package/src/kernel/legacy.ts

@@ -0,0 +1,43 @@
+/**
+ * Legacy adapters — keep existing A432 / VBM callers working.
+ * Kernel default: digitalRoot(0)→9 · VORTEX_SEQUENCE.
+ * Legacy: digitalRoot(0)→0 · consciousness 03691248751.
+ */
+
+import {
+  LEGACY_CONSCIOUSNESS_SEQUENCE,
+  VORTEX_ORBIT,
+  VORTEX_SEQUENCE,
+  digitalRoot as kernelDigitalRoot,
+} from '../0/index.ts'
+
+/** VBM / older zeropoint: 0 stays 0. */
+export function legacyDigitalRoot(n: number): number {
+  if (n === 0) return 0
+  return kernelDigitalRoot(n)
+}
+
+/** a432.math-style base-12 reduction used in some modules (unchanged semantics). */
+export function legacyHarmonicRoot12(n: number): number {
+  if (n === 0) return 0
+  const r = n % 12
+  return r === 0 ? 12 : r
+}
+
+export function legacyConsciousnessSequence(): readonly number[] {
+  return LEGACY_CONSCIOUSNESS_SEQUENCE
+}
+
+export function kernelVortexSequence(): readonly number[] {
+  return VORTEX_SEQUENCE
+}
+
+export function rodinOrbit(): readonly number[] {
+  return VORTEX_ORBIT
+}
+
+/** Map legacy consciousness index onto kernel vortex digit (same digits, different spine). */
+export function mapLegacyDigitToKernel(digit: number): number {
+  if (digit === 0) return 9
+  return kernelDigitalRoot(digit)
+}

package/src/kernel/lobes.ts

@@ -0,0 +1,222 @@
+/**
+ * lobes — offline, self-sufficient learning from the two sibling repositories.
+ *
+ * The double torus in this corpus is: lobe L = ceccec.github.io, lobe R =
+ * erpax, throat = src/0. This module lets the throat LEARN from either lobe
+ * without a network: it reads sibling checkouts if they happen to sit beside
+ * this one on disk, folds what it finds into content-addressed receipts, and
+ * reports honestly when a lobe is absent.
+ *
+ * Self-sufficient means exactly that — no fetch, no clone, no shell-out. Every
+ * function here returns a well-formed answer with zero lobes present. Absence
+ * is data, not an error.
+ *
+ * ON "QUANTUM" AND "FTL". Both words have DEFINED, computed meanings in this
+ * corpus and neither is a physics claim:
+ *   - erpax computes `ftlReport().holds` as reuse ∧ amortize∞ ∧ cracks=∅ —
+ *     a statement about not recomputing work, not about signalling faster than
+ *     light.
+ *   - `computeVortexInvariantsHold()` in src/0 derives a boolean from structural seals.
+ * Nothing here transmits information superluminally, and nothing here runs on
+ * quantum hardware. The names are the corpus's own labels for reuse and for
+ * seal-completeness. Read them that way.
+ */
+
+import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs'
+import { join, dirname, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { toUuid, merkleFold } from '../0/index.ts'
+
+const HERE = dirname(fileURLToPath(import.meta.url))
+/** Sibling checkouts live beside this repository, never inside it. */
+const NEIGHBOURHOOD = resolve(HERE, '../../..')
+
+export type LobeName = 'ceccec.github.io' | 'erpax'
+
+export type LobeSurface = {
+  readonly file: string
+  readonly bytes: number
+  readonly receipt: string
+}
+
+export type LobeReading = {
+  readonly lobe: LobeName
+  readonly present: boolean
+  readonly path: string | null
+  readonly surfaces: readonly LobeSurface[]
+  /** Named laws / gates the lobe declares, deduped and sorted. */
+  readonly laws: readonly string[]
+  readonly root: string
+}
+
+/** Orientation surfaces, in the order an agent is told to read them. */
+const SURFACE_FILES = ['AGENTS.md', 'SKILL.md', 'llms.txt', 'README.md'] as const
+
+/**
+ * Named laws a lobe declares. Both lobes name their gates in the same shape —
+ * a lowerCamelCase identifier stated as a rule — so one pattern reads both.
+ */
+const LAW = /\b([a-z][A-Za-z0-9]{6,}(?:Is|Are|Must|Refus|Carries|Holds|Fails|Requires)[A-Za-z0-9]*)\b/g
+
+function readSurface(dir: string, file: string): LobeSurface | null {
+  const p = join(dir, file)
+  if (!existsSync(p)) return null
+  const text = readFileSync(p, 'utf8')
+  return { file, bytes: text.length, receipt: toUuid(`lobe-surface:${file}:${text}`) }
+}
+
+function lawsIn(text: string): string[] {
+  const found = new Set<string>()
+  LAW.lastIndex = 0
+  for (const m of text.matchAll(LAW)) found.add(m[1]!)
+  return [...found].sort()
+}
+
+/** Read one lobe. Absent lobes return present:false, never throw. */
+export function readLobe(lobe: LobeName, neighbourhood: string = NEIGHBOURHOOD): LobeReading {
+  const dir = join(neighbourhood, lobe)
+  const present = existsSync(dir) && statSync(dir).isDirectory()
+  if (!present) {
+    return {
+      lobe,
+      present: false,
+      path: null,
+      surfaces: [],
+      laws: [],
+      root: toUuid(`lobe:absent:${lobe}`),
+    }
+  }
+  const surfaces: LobeSurface[] = []
+  const laws = new Set<string>()
+  for (const file of SURFACE_FILES) {
+    const s = readSurface(dir, file)
+    if (!s) continue
+    surfaces.push(s)
+    for (const law of lawsIn(readFileSync(join(dir, file), 'utf8'))) laws.add(law)
+  }
+  return {
+    lobe,
+    present: true,
+    path: dir,
+    surfaces,
+    laws: [...laws].sort(),
+    root: merkleFold([toUuid(`lobe:${lobe}`), ...surfaces.map((s) => s.receipt)]),
+  }
+}
+
+export type DoubleTorusReading = {
+  readonly lobes: readonly LobeReading[]
+  readonly present: number
+  /** Laws BOTH lobes state — the shared spine worth adopting here. */
+  readonly shared: readonly string[]
+  /** Laws exactly one lobe states — candidates to learn from. */
+  readonly unique: readonly { readonly lobe: LobeName; readonly law: string }[]
+  /** True when the throat can operate with no lobe present. */
+  readonly selfSufficient: true
+  readonly root: string
+  readonly boundary: string
+}
+
+/**
+ * Read both lobes and fold them. Works with zero, one or two present.
+ *
+ * `selfSufficient` is the literal type `true`: this function cannot report
+ * dependence on a lobe, because it has none. It is a claim about THIS code,
+ * not about the corpus.
+ */
+export function readDoubleTorus(neighbourhood: string = NEIGHBOURHOOD): DoubleTorusReading {
+  const lobes = (['ceccec.github.io', 'erpax'] as const).map((l) => readLobe(l, neighbourhood))
+  const [left, right] = lobes
+  const leftLaws = new Set(left!.laws)
+  const rightLaws = new Set(right!.laws)
+  const shared = [...leftLaws].filter((l) => rightLaws.has(l)).sort()
+  const unique: { lobe: LobeName; law: string }[] = []
+  for (const l of leftLaws) if (!rightLaws.has(l)) unique.push({ lobe: left!.lobe, law: l })
+  for (const l of rightLaws) if (!leftLaws.has(l)) unique.push({ lobe: right!.lobe, law: l })
+  return {
+    lobes,
+    present: lobes.filter((l) => l.present).length,
+    shared,
+    unique: unique.sort((a, b) => a.law.localeCompare(b.law)),
+    selfSufficient: true,
+    root: merkleFold(lobes.map((l) => l.root)),
+    boundary:
+      'Reads sibling checkouts from disk only — no network, no clone. Absent lobes are reported, not fetched. ' +
+      '"quantum" and "FTL" here are the corpus\'s labels for reuse and seal-completeness, not physics claims.',
+  }
+}
+
+export type LawAdoption = {
+  readonly law: string
+  readonly lobe: LobeName
+  /** Files in THIS repo that name the law, if any. */
+  readonly citedIn: readonly string[]
+}
+
+export type LobeLearning = {
+  readonly readable: number
+  readonly adopted: readonly LawAdoption[]
+  readonly candidates: readonly LawAdoption[]
+  readonly root: string
+  readonly boundary: string
+}
+
+const LEARN_DIRS = ['src', 'scripts', 'docs'] as const
+const LEARN_EXT = /\.(ts|mjs|js|md)$/
+
+function repoFiles(repoRoot: string): string[] {
+  const out: string[] = []
+  const skip = new Set(['node_modules', 'dist', 'coverage', '.git', '.vitepress'])
+  const walk = (dir: string) => {
+    if (!existsSync(dir)) return
+    for (const name of readdirSync(dir)) {
+      if (skip.has(name)) continue
+      const p = join(dir, name)
+      if (statSync(p).isDirectory()) walk(p)
+      else if (LEARN_EXT.test(name)) out.push(p)
+    }
+  }
+  for (const d of LEARN_DIRS) walk(join(repoRoot, d))
+  for (const f of ['README.md', 'AGENTS.md', 'SKILL.md']) {
+    const p = join(repoRoot, f)
+    if (existsSync(p)) out.push(p)
+  }
+  return out
+}
+
+/**
+ * Which laws the lobes declare that THIS repository already names, and which
+ * it does not.
+ *
+ * A candidate is NOT an obligation. Many of lobe L's laws are specific to its
+ * own registry and have no meaning here; the list is a reading queue, not a
+ * backlog. The point is that the gap is COMPUTED rather than remembered — the
+ * corpus can see what it has not yet looked at.
+ */
+export function lobeLearning(
+  neighbourhood: string = NEIGHBOURHOOD,
+  repoRoot: string = resolve(HERE, '../..'),
+): LobeLearning {
+  const torus = readDoubleTorus(neighbourhood)
+  const files = repoFiles(repoRoot)
+  const corpus = files.map((f) => ({ f, text: readFileSync(f, 'utf8') }))
+  const adopted: LawAdoption[] = []
+  const candidates: LawAdoption[] = []
+  for (const lobe of torus.lobes) {
+    for (const law of lobe.laws) {
+      const citedIn = corpus.filter((c) => c.text.includes(law)).map((c) => c.f)
+      const entry = { law, lobe: lobe.lobe, citedIn }
+      if (citedIn.length > 0) adopted.push(entry)
+      else candidates.push(entry)
+    }
+  }
+  return {
+    readable: adopted.length + candidates.length,
+    adopted,
+    candidates,
+    root: merkleFold([torus.root, toUuid(`lobe-learning:${adopted.length}:${candidates.length}`)]),
+    boundary:
+      'A candidate is a law this repo has never named — a reading queue, not a backlog. ' +
+      'Many lobe laws are specific to their own corpus and correctly do not apply here.',
+  }
+}