forgeos 0.1.0-alpha.0 → 0.1.0-alpha.2

package/src/forge/compiler/emitter/lock.ts

@@ -1,62 +1,62 @@
-import type { ForgeLock, ForgeLockEntry } from "../types/lock.ts";
-import type { SecretRequirement } from "../types/capability.ts";
-import {
-  compareBytes,
-  serializeCanonical,
-  stableSortByPath,
-  stableSortStrings,
-} from "../primitives/index.ts";
-
-function compareLockEntries(a: ForgeLockEntry, b: ForgeLockEntry): number {
-  return compareBytes(a.name, b.name);
-}
-
-function compareSecrets(a: SecretRequirement, b: SecretRequirement): number {
-  return compareBytes(a.envVar, b.envVar);
-}
-
-function stableSortLockEntries(entries: ForgeLockEntry[]): ForgeLockEntry[] {
-  return [...entries].sort(compareLockEntries);
-}
-
-function stableSortSecrets(secrets: SecretRequirement[]): SecretRequirement[] {
-  return [...secrets].sort(compareSecrets);
-}
-
-function canonicalizeLockEntry(entry: ForgeLockEntry): ForgeLockEntry {
-  return {
-    name: entry.name,
-    version: entry.version,
-    ...(entry.recipeVersion !== undefined
-      ? { recipeVersion: entry.recipeVersion }
-      : {}),
+import type { ForgeLock, ForgeLockEntry } from "../types/lock.ts";
+import type { SecretRequirement } from "../types/capability.ts";
+import {
+  compareBytes,
+  serializeCanonical,
+  stableSortByPath,
+  stableSortStrings,
+} from "../primitives/index.ts";
+
+function compareLockEntries(a: ForgeLockEntry, b: ForgeLockEntry): number {
+  return compareBytes(a.name, b.name);
+}
+
+function compareSecrets(a: SecretRequirement, b: SecretRequirement): number {
+  return compareBytes(a.envVar, b.envVar);
+}
+
+function stableSortLockEntries(entries: ForgeLockEntry[]): ForgeLockEntry[] {
+  return [...entries].sort(compareLockEntries);
+}
+
+function stableSortSecrets(secrets: SecretRequirement[]): SecretRequirement[] {
+  return [...secrets].sort(compareSecrets);
+}
+
+function canonicalizeLockEntry(entry: ForgeLockEntry): ForgeLockEntry {
+  return {
+    name: entry.name,
+    version: entry.version,
+    ...(entry.recipeVersion !== undefined
+      ? { recipeVersion: entry.recipeVersion }
+      : {}),
     runtimeContexts: stableSortStrings([...entry.runtimeContexts]) as ForgeLockEntry["runtimeContexts"],
-    capabilities: {
-      ...entry.capabilities,
-      secrets: stableSortSecrets([...entry.capabilities.secrets]),
-    },
-    secrets: stableSortSecrets([...entry.secrets]),
-    generatedFiles: stableSortByPath([...entry.generatedFiles]),
-    contentChecksum: entry.contentChecksum,
-  };
-}
-
-/**
- * Deterministic forge.lock serialization (no deterministic header).
- */
-export function serializeForgeLock(lock: ForgeLock): string {
-  const canonical: ForgeLock = {
-    schemaVersion: lock.schemaVersion,
-    generatorVersion: lock.generatorVersion,
-    analyzerVersion: lock.analyzerVersion,
-    inputHash: lock.inputHash,
-    lockfileHash: lock.lockfileHash,
-    packageManager: lock.packageManager,
-    ...(lock.recipeVersion !== undefined
-      ? { recipeVersion: lock.recipeVersion }
-      : {}),
-    packages: stableSortLockEntries(lock.packages).map(canonicalizeLockEntry),
-  };
-
-  return serializeCanonical(canonical);
-}
+    capabilities: {
+      ...entry.capabilities,
+      secrets: stableSortSecrets([...entry.capabilities.secrets]),
+    },
+    secrets: stableSortSecrets([...entry.secrets]),
+    generatedFiles: stableSortByPath([...entry.generatedFiles]),
+    contentChecksum: entry.contentChecksum,
+  };
+}
+
+/**
+ * Deterministic forge.lock serialization (no deterministic header).
+ */
+export function serializeForgeLock(lock: ForgeLock): string {
+  const canonical: ForgeLock = {
+    schemaVersion: lock.schemaVersion,
+    generatorVersion: lock.generatorVersion,
+    analyzerVersion: lock.analyzerVersion,
+    inputHash: lock.inputHash,
+    lockfileHash: lock.lockfileHash,
+    packageManager: lock.packageManager,
+    ...(lock.recipeVersion !== undefined
+      ? { recipeVersion: lock.recipeVersion }
+      : {}),
+    packages: stableSortLockEntries(lock.packages).map(canonicalizeLockEntry),
+  };
+
+  return serializeCanonical(canonical);
+}

package/src/forge/compiler/emitter/render.ts

@@ -1,73 +1,73 @@
-import type { EmitFile } from "../types/emit.ts";
-import {
-  hashStable,
-  prependDeterministicHeader,
-  normalizeNewlines,
-  serializeCanonical,
-} from "../primitives/index.ts";
-import { detectArtifactKind } from "./artifact-kind.ts";
-
-export interface RenderContext {
-  generatorVersion: string;
-  inputHash: string;
-}
-
-function renderJsonBody(content: string): string {
-  try {
-    const parsed: unknown = JSON.parse(content);
-    return serializeCanonical(parsed);
-  } catch {
-    return normalizeNewlines(content);
-  }
-}
-
-function renderTypeScriptBody(content: string): string {
-  return normalizeNewlines(content);
-}
-
-function renderMarkdownBody(content: string): string {
-  return normalizeNewlines(content);
-}
-
-function renderTextBody(content: string): string {
-  return normalizeNewlines(content);
-}
-
-/**
- * Normalize file body bytes by artifact kind (no deterministic header).
- */
-export function renderBody(file: EmitFile): string {
-  const kind = detectArtifactKind(file.path);
-
-  switch (kind) {
-    case "json":
-      if (file.canonical) {
-        return normalizeNewlines(file.content);
-      }
-      return renderJsonBody(file.content);
-    case "typescript":
-      return renderTypeScriptBody(file.content);
-    case "markdown":
-      return renderMarkdownBody(file.content);
-    default:
-      return renderTextBody(file.content);
-  }
-}
-
-/**
- * Pure render: same EmitFile + context → same bytes (header included).
- */
-export function render(file: EmitFile, context: RenderContext): string {
-  const body = renderBody(file);
-
-  if (file.contentHash !== hashStable(body)) {
-    throw new Error(
-      `EmitFile contentHash mismatch for ${file.path}: expected ${hashStable(body)}, got ${file.contentHash}`,
-    );
-  }
-
-  return prependDeterministicHeader(body, {
-    generatorVersion: context.generatorVersion,
-    inputHash: context.inputHash,
-  });
-}
+import type { EmitFile } from "../types/emit.ts";
+import {
+  hashStable,
+  prependDeterministicHeader,
+  normalizeNewlines,
+  serializeCanonical,
+} from "../primitives/index.ts";
+import { detectArtifactKind } from "./artifact-kind.ts";
+
+export interface RenderContext {
+  generatorVersion: string;
+  inputHash: string;
+}
+
+function renderJsonBody(content: string): string {
+  try {
+    const parsed: unknown = JSON.parse(content);
+    return serializeCanonical(parsed);
+  } catch {
+    return normalizeNewlines(content);
+  }
+}
+
+function renderTypeScriptBody(content: string): string {
+  return normalizeNewlines(content);
+}
+
+function renderMarkdownBody(content: string): string {
+  return normalizeNewlines(content);
+}
+
+function renderTextBody(content: string): string {
+  return normalizeNewlines(content);
+}
+
+/**
+ * Normalize file body bytes by artifact kind (no deterministic header).
+ */
+export function renderBody(file: EmitFile): string {
+  const kind = detectArtifactKind(file.path);
+
+  switch (kind) {
+    case "json":
+      if (file.canonical) {
+        return normalizeNewlines(file.content);
+      }
+      return renderJsonBody(file.content);
+    case "typescript":
+      return renderTypeScriptBody(file.content);
+    case "markdown":
+      return renderMarkdownBody(file.content);
+    default:
+      return renderTextBody(file.content);
+  }
+}
+
+/**
+ * Pure render: same EmitFile + context → same bytes (header included).
+ */
+export function render(file: EmitFile, context: RenderContext): string {
+  const body = renderBody(file);
+
+  if (file.contentHash !== hashStable(body)) {
+    throw new Error(
+      `EmitFile contentHash mismatch for ${file.path}: expected ${hashStable(body)}, got ${file.contentHash}`,
+    );
+  }
+
+  return prependDeterministicHeader(body, {
+    generatorVersion: context.generatorVersion,
+    inputHash: context.inputHash,
+  });
+}

package/src/forge/compiler/guards/artifacts.ts

@@ -1,96 +1,96 @@
-import { GENERATED_DIR } from "../emitter/constants.ts";
-import { hashStable, serializeCanonical } from "../primitives/index.ts";
-import type { EmitFile } from "../types/emit.ts";
-import type { ModuleGraph } from "../types/app-graph.ts";
-import type { ImportGuardsArtifact } from "../types/import-guards.ts";
-import type { RuntimeMatrix } from "../types/runtime-matrix.ts";
-import { propagateContexts } from "./propagate-contexts.ts";
-
-export function buildImportGuardsArtifact(
-  matrix: RuntimeMatrix,
-  moduleGraph?: ModuleGraph,
-): ImportGuardsArtifact {
-  const entries = matrix.entries.map((entry) => ({
-    packageName: entry.packageName,
-    alias: entry.alias,
-    compatible: [...entry.compatible],
-    incompatible: [...entry.incompatible],
-    rationale: { ...entry.rationale },
-  }));
-
-  let moduleContexts: ImportGuardsArtifact["moduleContexts"] = [];
-  if (moduleGraph) {
-    propagateContexts(moduleGraph);
-    moduleContexts = moduleGraph.nodes
-      .filter((node) => node.effectiveContexts.length > 0)
-      .map((node) => ({
-        file: node.file,
-        effectiveContexts: [...node.effectiveContexts],
-      }))
-      .sort((a, b) => (a.file < b.file ? -1 : a.file > b.file ? 1 : 0));
-  }
-
-  return {
-    schemaVersion: matrix.schemaVersion,
-    entries,
-    moduleContexts,
-  };
-}
-
-function renderRuntimeMatrixTs(matrix: RuntimeMatrix): string {
-  return `export const runtimeMatrix = ${serializeCanonical(matrix).trim()} as const;\n`;
-}
-
-function renderImportGuardsTs(artifact: ImportGuardsArtifact): string {
-  return `export const importGuards = ${serializeCanonical(artifact).trim()} as const;\n`;
-}
-
-export function buildRuntimeMatrixEmitFiles(matrix: RuntimeMatrix): EmitFile[] {
-  const jsonBody = serializeCanonical(matrix);
-  const tsBody = renderRuntimeMatrixTs(matrix);
-
-  return [
-    {
-      path: `${GENERATED_DIR}/runtimeMatrix.json`,
-      content: jsonBody,
-      contentHash: hashStable(jsonBody),
-    },
-    {
-      path: `${GENERATED_DIR}/runtimeMatrix.ts`,
-      content: tsBody,
-      contentHash: hashStable(tsBody),
-    },
-  ];
-}
-
-export function buildImportGuardsEmitFiles(
-  matrix: RuntimeMatrix,
-  moduleGraph?: ModuleGraph,
-): EmitFile[] {
-  const artifact = buildImportGuardsArtifact(matrix, moduleGraph);
-  const jsonBody = serializeCanonical(artifact);
-  const tsBody = renderImportGuardsTs(artifact);
-
-  return [
-    {
-      path: `${GENERATED_DIR}/importGuards.json`,
-      content: jsonBody,
-      contentHash: hashStable(jsonBody),
-    },
-    {
-      path: `${GENERATED_DIR}/importGuards.ts`,
-      content: tsBody,
-      contentHash: hashStable(tsBody),
-    },
-  ];
-}
-
-export function buildGuardArtifactEmitFiles(
-  matrix: RuntimeMatrix,
-  moduleGraph?: ModuleGraph,
-): EmitFile[] {
-  return [
-    ...buildRuntimeMatrixEmitFiles(matrix),
-    ...buildImportGuardsEmitFiles(matrix, moduleGraph),
-  ];
-}
+import { GENERATED_DIR } from "../emitter/constants.ts";
+import { hashStable, serializeCanonical } from "../primitives/index.ts";
+import type { EmitFile } from "../types/emit.ts";
+import type { ModuleGraph } from "../types/app-graph.ts";
+import type { ImportGuardsArtifact } from "../types/import-guards.ts";
+import type { RuntimeMatrix } from "../types/runtime-matrix.ts";
+import { propagateContexts } from "./propagate-contexts.ts";
+
+export function buildImportGuardsArtifact(
+  matrix: RuntimeMatrix,
+  moduleGraph?: ModuleGraph,
+): ImportGuardsArtifact {
+  const entries = matrix.entries.map((entry) => ({
+    packageName: entry.packageName,
+    alias: entry.alias,
+    compatible: [...entry.compatible],
+    incompatible: [...entry.incompatible],
+    rationale: { ...entry.rationale },
+  }));
+
+  let moduleContexts: ImportGuardsArtifact["moduleContexts"] = [];
+  if (moduleGraph) {
+    propagateContexts(moduleGraph);
+    moduleContexts = moduleGraph.nodes
+      .filter((node) => node.effectiveContexts.length > 0)
+      .map((node) => ({
+        file: node.file,
+        effectiveContexts: [...node.effectiveContexts],
+      }))
+      .sort((a, b) => (a.file < b.file ? -1 : a.file > b.file ? 1 : 0));
+  }
+
+  return {
+    schemaVersion: matrix.schemaVersion,
+    entries,
+    moduleContexts,
+  };
+}
+
+function renderRuntimeMatrixTs(matrix: RuntimeMatrix): string {
+  return `export const runtimeMatrix = ${serializeCanonical(matrix).trim()} as const;\n`;
+}
+
+function renderImportGuardsTs(artifact: ImportGuardsArtifact): string {
+  return `export const importGuards = ${serializeCanonical(artifact).trim()} as const;\n`;
+}
+
+export function buildRuntimeMatrixEmitFiles(matrix: RuntimeMatrix): EmitFile[] {
+  const jsonBody = serializeCanonical(matrix);
+  const tsBody = renderRuntimeMatrixTs(matrix);
+
+  return [
+    {
+      path: `${GENERATED_DIR}/runtimeMatrix.json`,
+      content: jsonBody,
+      contentHash: hashStable(jsonBody),
+    },
+    {
+      path: `${GENERATED_DIR}/runtimeMatrix.ts`,
+      content: tsBody,
+      contentHash: hashStable(tsBody),
+    },
+  ];
+}
+
+export function buildImportGuardsEmitFiles(
+  matrix: RuntimeMatrix,
+  moduleGraph?: ModuleGraph,
+): EmitFile[] {
+  const artifact = buildImportGuardsArtifact(matrix, moduleGraph);
+  const jsonBody = serializeCanonical(artifact);
+  const tsBody = renderImportGuardsTs(artifact);
+
+  return [
+    {
+      path: `${GENERATED_DIR}/importGuards.json`,
+      content: jsonBody,
+      contentHash: hashStable(jsonBody),
+    },
+    {
+      path: `${GENERATED_DIR}/importGuards.ts`,
+      content: tsBody,
+      contentHash: hashStable(tsBody),
+    },
+  ];
+}
+
+export function buildGuardArtifactEmitFiles(
+  matrix: RuntimeMatrix,
+  moduleGraph?: ModuleGraph,
+): EmitFile[] {
+  return [
+    ...buildRuntimeMatrixEmitFiles(matrix),
+    ...buildImportGuardsEmitFiles(matrix, moduleGraph),
+  ];
+}

package/src/forge/compiler/guards/check-import-guards.ts

@@ -1,106 +1,106 @@
-import { lookupMatrixEntry } from "../classifier/runtime-matrix.ts";
-import { forgeGuardViolation } from "../diagnostics/create.ts";
-import type { ModuleGraph } from "../types/app-graph.ts";
-import type { Diagnostic } from "../types/diagnostic.ts";
-import type { RuntimeContext } from "../types/runtime.ts";
-import type { RuntimeMatrix } from "../types/runtime-matrix.ts";
-import { comparePaths } from "../primitives/paths.ts";
-import { compareBytes } from "../primitives/compare.ts";
-import { propagateContexts } from "./propagate-contexts.ts";
-
-function compareDiagnostics(a: Diagnostic, b: Diagnostic): number {
-  let cmp = comparePaths(a.file ?? "", b.file ?? "");
-  if (cmp !== 0) {
-    return cmp;
-  }
-
-  cmp = (a.span?.start ?? 0) - (b.span?.start ?? 0);
-  if (cmp !== 0) {
-    return cmp;
-  }
-
-  const aPackage = extractPackageName(a.message);
-  const bPackage = extractPackageName(b.message);
-  cmp = compareBytes(aPackage, bPackage);
-  if (cmp !== 0) {
-    return cmp;
-  }
-
-  const aContext = extractContext(a.message);
-  const bContext = extractContext(b.message);
-  return compareBytes(aContext, bContext);
-}
-
-function extractPackageName(message: string): string {
-  const match = /^'([^']+)' is not allowed/.exec(message);
-  return match?.[1] ?? "";
-}
-
-function extractContext(message: string): string {
-  const match = /'([^']+)' context/.exec(message);
-  return match?.[1] ?? "";
-}
-
-/**
- * Evaluate package imports against the runtime matrix after propagating effective contexts.
- */
-export function checkImportGuards(
-  moduleGraph: ModuleGraph,
-  matrix: RuntimeMatrix,
-): Diagnostic[] {
-  propagateContexts(moduleGraph);
-
-  const diagnostics: Diagnostic[] = [];
-  const recorded = new Set<string>();
-
-  for (const node of moduleGraph.nodes) {
-    if (node.effectiveContexts.length === 0) {
-      continue;
-    }
-
-    for (const imp of node.directPackageImports) {
-      const entry = lookupMatrixEntry(matrix, imp.packageName);
-      if (entry == null) {
-        continue;
-      }
-
-      for (const context of node.effectiveContexts) {
-        if (!entry.compatible.includes(context)) {
-          const key = `${node.file}\0${imp.packageName}\0${context}\0${imp.span.start}`;
-          if (recorded.has(key)) {
-            continue;
-          }
-          recorded.add(key);
-
-          const rationale =
-            entry.rationale[context] ??
-            "package is incompatible with this runtime context";
-          diagnostics.push(
-            forgeGuardViolation(
-              imp.packageName,
-              context,
-              rationale,
-              node.file,
-              imp.span,
-            ),
-          );
-        }
-      }
-    }
-  }
-
-  diagnostics.sort(compareDiagnostics);
-  return diagnostics;
-}
-
-export function isContextViolating(
-  matrix: RuntimeMatrix,
-  packageName: string,
-  context: RuntimeContext,
-): boolean {
-  const entry = lookupMatrixEntry(matrix, packageName);
-  if (entry == null) {
-    return false;
-  }
-  return !entry.compatible.includes(context);
-}
+import { lookupMatrixEntry } from "../classifier/runtime-matrix.ts";
+import { forgeGuardViolation } from "../diagnostics/create.ts";
+import type { ModuleGraph } from "../types/app-graph.ts";
+import type { Diagnostic } from "../types/diagnostic.ts";
+import type { RuntimeContext } from "../types/runtime.ts";
+import type { RuntimeMatrix } from "../types/runtime-matrix.ts";
+import { comparePaths } from "../primitives/paths.ts";
+import { compareBytes } from "../primitives/compare.ts";
+import { propagateContexts } from "./propagate-contexts.ts";
+
+function compareDiagnostics(a: Diagnostic, b: Diagnostic): number {
+  let cmp = comparePaths(a.file ?? "", b.file ?? "");
+  if (cmp !== 0) {
+    return cmp;
+  }
+
+  cmp = (a.span?.start ?? 0) - (b.span?.start ?? 0);
+  if (cmp !== 0) {
+    return cmp;
+  }
+
+  const aPackage = extractPackageName(a.message);
+  const bPackage = extractPackageName(b.message);
+  cmp = compareBytes(aPackage, bPackage);
+  if (cmp !== 0) {
+    return cmp;
+  }
+
+  const aContext = extractContext(a.message);
+  const bContext = extractContext(b.message);
+  return compareBytes(aContext, bContext);
+}
+
+function extractPackageName(message: string): string {
+  const match = /^'([^']+)' is not allowed/.exec(message);
+  return match?.[1] ?? "";
+}
+
+function extractContext(message: string): string {
+  const match = /'([^']+)' context/.exec(message);
+  return match?.[1] ?? "";
+}
+
+/**
+ * Evaluate package imports against the runtime matrix after propagating effective contexts.
+ */
+export function checkImportGuards(
+  moduleGraph: ModuleGraph,
+  matrix: RuntimeMatrix,
+): Diagnostic[] {
+  propagateContexts(moduleGraph);
+
+  const diagnostics: Diagnostic[] = [];
+  const recorded = new Set<string>();
+
+  for (const node of moduleGraph.nodes) {
+    if (node.effectiveContexts.length === 0) {
+      continue;
+    }
+
+    for (const imp of node.directPackageImports) {
+      const entry = lookupMatrixEntry(matrix, imp.packageName);
+      if (entry == null) {
+        continue;
+      }
+
+      for (const context of node.effectiveContexts) {
+        if (!entry.compatible.includes(context)) {
+          const key = `${node.file}\0${imp.packageName}\0${context}\0${imp.span.start}`;
+          if (recorded.has(key)) {
+            continue;
+          }
+          recorded.add(key);
+
+          const rationale =
+            entry.rationale[context] ??
+            "package is incompatible with this runtime context";
+          diagnostics.push(
+            forgeGuardViolation(
+              imp.packageName,
+              context,
+              rationale,
+              node.file,
+              imp.span,
+            ),
+          );
+        }
+      }
+    }
+  }
+
+  diagnostics.sort(compareDiagnostics);
+  return diagnostics;
+}
+
+export function isContextViolating(
+  matrix: RuntimeMatrix,
+  packageName: string,
+  context: RuntimeContext,
+): boolean {
+  const entry = lookupMatrixEntry(matrix, packageName);
+  if (entry == null) {
+    return false;
+  }
+  return !entry.compatible.includes(context);
+}