forgeos 0.1.0-alpha.4 → 0.1.0-alpha.41

package/src/forge/compiler/data-graph/sql/ddl.ts

@@ -34,6 +34,7 @@ const SYSTEM_LIVE_SUBSCRIPTION_DEBUG_SQL = `CREATE TABLE IF NOT EXISTS _forge_li
 
 interface ParsedFieldType {
   sqlType: string;
+  nullable?: boolean;
   references?: { table: string; column: string };
   checkConstraint?: string;
 }
@@ -42,36 +43,100 @@ function stableSortTables(tables: DataTable[]): DataTable[] {
   return [...tables].sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
 }
 
+function stableSortTableChangesByReferences(tables: SqlChange[]): SqlChange[] {
+  const orderedInput = [...tables].sort((a, b) => {
+    const tableA = a.table ?? "";
+    const tableB = b.table ?? "";
+    return tableA < tableB ? -1 : tableA > tableB ? 1 : 0;
+  });
+  const byName = new Map<string, SqlChange>();
+
+  for (const table of orderedInput) {
+    if (table.table) {
+      byName.set(table.table, table);
+    }
+  }
+
+  const pending = new Set(byName.keys());
+  const emitted = new Set<string>();
+  const ordered: SqlChange[] = [];
+
+  while (pending.size > 0) {
+    let progressed = false;
+
+    for (const tableName of pending) {
+      const table = byName.get(tableName);
+      if (!table) {
+        pending.delete(tableName);
+        continue;
+      }
+
+      const dependencies = (table.columns ?? [])
+        .map((column) => column.references?.table)
+        .filter((dependency): dependency is string => Boolean(dependency))
+        .filter((dependency) => dependency !== tableName && byName.has(dependency));
+
+      if (dependencies.every((dependency) => emitted.has(dependency))) {
+        ordered.push(table);
+        emitted.add(tableName);
+        pending.delete(tableName);
+        progressed = true;
+      }
+    }
+
+    if (!progressed) {
+      for (const tableName of pending) {
+        const table = byName.get(tableName);
+        if (table) {
+          ordered.push(table);
+        }
+      }
+      break;
+    }
+  }
+
+  return ordered;
+}
+
 function parseFieldType(
   field: DataField,
   tableName: string,
   diagnostics: Diagnostic[],
+  refTables: Map<string, string>,
 ): ParsedFieldType | null {
-  const raw = field.type.trim().toLowerCase();
+  const declared = field.type.trim();
+  const nullable = declared.endsWith("?");
+  const raw = (nullable ? declared.slice(0, -1) : declared).trim();
+  const lowered = raw.toLowerCase();
+
+  const withNullability = (parsed: Omit<ParsedFieldType, "nullable">): ParsedFieldType => ({
+    ...parsed,
+    ...(nullable ? { nullable: true } : {}),
+  });
 
-  if (raw === "uuid") {
-    return { sqlType: "uuid" };
+  if (lowered === "uuid") {
+    return withNullability({ sqlType: "uuid" });
   }
-  if (raw === "text" || raw === "string") {
-    return { sqlType: "text" };
+  if (lowered === "text" || lowered === "string") {
+    return withNullability({ sqlType: "text" });
   }
-  if (raw === "number") {
-    return { sqlType: "double precision" };
+  if (lowered === "number") {
+    return withNullability({ sqlType: "double precision" });
   }
-  if (raw === "integer" || raw === "int") {
-    return { sqlType: "integer" };
+  if (lowered === "integer" || lowered === "int") {
+    return withNullability({ sqlType: "integer" });
   }
-  if (raw === "boolean" || raw === "bool") {
-    return { sqlType: "boolean" };
+  if (lowered === "boolean" || lowered === "bool") {
+    return withNullability({ sqlType: "boolean" });
   }
-  if (raw === "timestamp") {
-    return { sqlType: "timestamptz" };
+  if (lowered === "timestamp" || lowered === "timestamptz") {
+    return withNullability({ sqlType: "timestamptz" });
   }
-  if (raw === "json") {
-    return { sqlType: "jsonb" };
+  if (lowered === "json") {
+    return withNullability({ sqlType: "jsonb" });
   }
 
-  if (raw.startsWith("enum:")) {
+  if (lowered.startsWith("enum:")) {
     const values = raw
       .slice("enum:".length)
       .split(",")
@@ -89,16 +154,17 @@ function parseFieldType(
     }
     const checkValues = values.map((value) => `'${value.replace(/'/g, "''")}'`).join(", ");
     return {
+      ...(nullable ? { nullable: true } : {}),
       sqlType: "text",
       checkConstraint: `${quoteIdent(toSnakeCase(field.name))} IN (${checkValues})`,
     };
   }
 
-  if (raw.startsWith("enum_")) {
-    return { sqlType: "text" };
+  if (lowered.startsWith("enum_")) {
+    return withNullability({ sqlType: "text" });
   }
 
-  if (raw.startsWith("ref:")) {
+  if (lowered.startsWith("ref:")) {
     const refTable = raw.slice("ref:".length).trim();
     if (!refTable) {
       diagnostics.push(
@@ -110,14 +176,27 @@ function parseFieldType(
       );
       return null;
     }
+    const resolvedRefTable = refTables.get(refTable) ?? refTables.get(toSnakeCase(refTable));
+    if (!resolvedRefTable) {
+      diagnostics.push(
+        createDiagnostic({
+          severity: "error",
+          code: FORGE_DB_INVALID_SQL_PLAN,
+          message: `unknown ref target '${refTable}' on ${tableName}.${field.name}; expected one of ${[...new Set(refTables.values())].sort().join(", ")}`,
+        }),
+      );
+      return null;
+    }
     return {
+      ...(nullable ? { nullable: true } : {}),
       sqlType: "uuid",
-      references: { table: toSnakeCase(refTable), column: "id" },
+      references: { table: resolvedRefTable, column: "id" },
     };
   }
 
-  if (raw === "ref") {
+  if (lowered === "ref") {
     return {
+      ...(nullable ? { nullable: true } : {}),
       sqlType: "uuid",
       references: { table: toSnakeCase(field.name.replace(/Id$/i, "")), column: "id" },
     };
@@ -133,9 +212,21 @@ function parseFieldType(
   return null;
 }
 
+function buildReferenceTableLookup(tables: DataTable[]): Map<string, string> {
+  const lookup = new Map<string, string>();
+  for (const table of tables) {
+    const sqlTableName = toSnakeCase(table.name);
+    lookup.set(table.name, sqlTableName);
+    lookup.set(table.exportName, sqlTableName);
+    lookup.set(sqlTableName, sqlTableName);
+    lookup.set(toSnakeCase(table.exportName), sqlTableName);
+  }
+  return lookup;
+}
+
 function defaultExprForField(field: DataField): string | undefined {
   const name = field.name;
-  const type = field.type.trim().toLowerCase();
+  const type = field.type.trim().replace(/\?$/, "").toLowerCase();
 
   if (name === "id" && type === "uuid") {
     return "gen_random_uuid()";
@@ -151,7 +242,11 @@ function defaultExprForField(field: DataField): string | undefined {
   return undefined;
 }
 
-function buildColumns(table: DataTable, diagnostics: Diagnostic[]): ColumnDef[] {
+function buildColumns(
+  table: DataTable,
+  diagnostics: Diagnostic[],
+  refTables: Map<string, string>,
+): ColumnDef[] {
   const columns: ColumnDef[] = [];
   const fields = [...table.fields].sort((a, b) =>
     a.name < b.name ? -1 : a.name > b.name ? 1 : 0,
@@ -170,7 +265,7 @@ function buildColumns(table: DataTable, diagnostics: Diagnostic[]): ColumnDef[]
   }
 
   for (const field of fields) {
-    const parsed = parseFieldType(field, table.name, diagnostics);
+    const parsed = parseFieldType(field, table.name, diagnostics, refTables);
     if (!parsed) {
       continue;
     }
@@ -183,7 +278,7 @@ function buildColumns(table: DataTable, diagnostics: Diagnostic[]): ColumnDef[]
       name: snakeName,
       fieldName: field.name,
       sqlType: parsed.sqlType,
-      nullable: false,
+      nullable: isPrimaryKey ? false : parsed.nullable === true,
       primaryKey: isPrimaryKey,
       defaultExpr,
       references: parsed.references,
@@ -191,7 +286,17 @@ function buildColumns(table: DataTable, diagnostics: Diagnostic[]): ColumnDef[]
     });
   }
 
-  if (!columns.some((column) => column.primaryKey) && columns.length > 0) {
+  if (hasIdField && !columns.some((column) => column.name === "id" && column.primaryKey)) {
+    const idField = fields.find((field) => field.name === "id");
+    diagnostics.push(
+      createDiagnostic({
+        severity: "warning",
+        code: FORGE_DB_INVALID_SQL_PLAN,
+        message: `table '${table.name}' declares id as '${idField?.type ?? "unknown"}'; Forge runtime requires id: "uuid" or no id field so Forge can generate one`,
+        file: table.file,
+      }),
+    );
+  } else if (!columns.some((column) => column.primaryKey) && columns.length > 0) {
     columns[0]!.primaryKey = true;
   }
 
@@ -235,9 +340,13 @@ function buildForeignKeyIndexes(tableName: string, columns: ColumnDef[]): IndexD
   return indexes;
 }
 
-function buildTableChange(table: DataTable, diagnostics: Diagnostic[]): SqlChange | null {
+function buildTableChange(
+  table: DataTable,
+  diagnostics: Diagnostic[],
+  refTables: Map<string, string>,
+): SqlChange | null {
   const tableName = toSnakeCase(table.name);
-  const columns = buildColumns(table, diagnostics);
+  const columns = buildColumns(table, diagnostics, refTables);
 
   if (columns.length === 0) {
     diagnostics.push(
@@ -254,6 +363,7 @@ function buildTableChange(table: DataTable, diagnostics: Diagnostic[]): SqlChang
   return {
     kind: "create_table",
     table: tableName,
+    accessName: table.name,
     columns,
     sql: buildCreateTableSql(tableName, columns),
   };
@@ -274,6 +384,7 @@ export function buildSqlPlan(dataGraph: DataGraph): SqlPlan {
   const diagnostics: Diagnostic[] = [];
   const tables: SqlChange[] = [];
   const indexes: SqlChange[] = [];
+  const refTables = buildReferenceTableLookup(dataGraph.tables);
 
   const systemTables: SqlChange[] = [
     {
@@ -329,7 +440,7 @@ export function buildSqlPlan(dataGraph: DataGraph): SqlPlan {
   ];
 
   for (const table of stableSortTables(dataGraph.tables)) {
-    const change = buildTableChange(table, diagnostics);
+    const change = buildTableChange(table, diagnostics, refTables);
     if (!change) {
       continue;
     }
@@ -342,6 +453,8 @@ export function buildSqlPlan(dataGraph: DataGraph): SqlPlan {
     }
   }
 
+  const orderedTables = stableSortTableChangesByReferences(tables);
+
   indexes.sort((a, b) => {
     const nameA = a.index?.name ?? "";
     const nameB = b.index?.name ?? "";
@@ -364,7 +477,7 @@ export function buildSqlPlan(dataGraph: DataGraph): SqlPlan {
   const payload = {
     schemaVersion: SQL_PLAN_SCHEMA_VERSION,
     systemTables: systemTables.map((change) => change.sql),
-    tables: tables.map((change) => change.sql),
+    tables: orderedTables.map((change) => change.sql),
     indexes: indexes.map((change) => change.sql),
   };
 
@@ -376,7 +489,7 @@ export function buildSqlPlan(dataGraph: DataGraph): SqlPlan {
     migrationId,
     checksum,
     systemTables,
-    tables,
+    tables: orderedTables,
     indexes,
     diagnostics: diagnostics.sort((a, b) => {
       const fileA = a.file ?? "";

package/src/forge/compiler/data-graph/sql/serialize.ts

@@ -15,6 +15,7 @@ export function serializeSqlPlanJson(plan: SqlPlan): string {
     tables: plan.tables.map((change) => ({
       kind: change.kind,
       table: change.table,
+      accessName: change.accessName,
       columns: change.columns,
       sql: change.sql,
     })),
@@ -69,6 +70,9 @@ export function buildTableMap(
         ? { tenantScoped: true, tenantIdColumn }
         : {}),
     };
+    if (change.accessName && change.accessName !== change.table) {
+      map[change.accessName] = map[change.table]!;
+    }
   }
 
   return map;

package/src/forge/compiler/data-graph/sql/types.ts

@@ -21,6 +21,7 @@ export interface IndexDef {
 export interface SqlChange {
   kind: "create_table" | "create_index" | "create_sequence";
   table?: string;
+  accessName?: string;
   columns?: ColumnDef[];
   index?: IndexDef;
   sql: string;

package/src/forge/compiler/diagnostics/codes.ts

@@ -27,19 +27,34 @@ export const FORGE_DUP_RUNTIME_ENTRY = "FORGE_DUP_RUNTIME_ENTRY" as const;
 export const FORGE_RUNTIME_UNRESOLVABLE = "FORGE_RUNTIME_UNRESOLVABLE" as const;
 export const FORGE_RUNTIME_NOT_FOUND = "FORGE_RUNTIME_NOT_FOUND" as const;
 export const FORGE_RUNTIME_GUARD_BLOCKED = "FORGE_RUNTIME_GUARD_BLOCKED" as const;
+export const FORGE_RUNTIME_EXPORT_NAME_REQUIRED =
+  "FORGE_RUNTIME_EXPORT_NAME_REQUIRED" as const;
+export const FORGE_EXTERNAL_RUNTIME_NOT_FOUND =
+  "FORGE_EXTERNAL_RUNTIME_NOT_FOUND" as const;
+export const FORGE_EXTERNAL_RUNTIME_UNSUPPORTED =
+  "FORGE_EXTERNAL_RUNTIME_UNSUPPORTED" as const;
+export const FORGE_EXTERNAL_RUNTIME_FAILED =
+  "FORGE_EXTERNAL_RUNTIME_FAILED" as const;
+export const FORGE_EXTERNAL_RUNTIME_BAD_RESPONSE =
+  "FORGE_EXTERNAL_RUNTIME_BAD_RESPONSE" as const;
 export const FORGE_DEV_SERVER_ERROR = "FORGE_DEV_SERVER_ERROR" as const;
 export const FORGE_DEV_WATCH_FAILED = "FORGE_DEV_WATCH_FAILED" as const;
 export const FORGE_DEV_INVOKE_FAILED = "FORGE_DEV_INVOKE_FAILED" as const;
 export const FORGE_DEV_DOCTOR_MISSING_ARTIFACT =
   "FORGE_DEV_DOCTOR_MISSING_ARTIFACT" as const;
+export const FORGE_DEV_DB_RESET = "FORGE_DEV_DB_RESET" as const;
 export const FORGE_DB_CONNECT_FAILED = "FORGE_DB_CONNECT_FAILED" as const;
 export const FORGE_DB_MIGRATION_FAILED = "FORGE_DB_MIGRATION_FAILED" as const;
 export const FORGE_DB_UNSUPPORTED_FIELD_TYPE =
   "FORGE_DB_UNSUPPORTED_FIELD_TYPE" as const;
 export const FORGE_DB_INVALID_SQL_PLAN = "FORGE_DB_INVALID_SQL_PLAN" as const;
+export const FORGE_DB_EMPTY_TIMESTAMP_LITERAL =
+  "FORGE_DB_EMPTY_TIMESTAMP_LITERAL" as const;
 export const FORGE_DB_TRANSACTION_FAILED = "FORGE_DB_TRANSACTION_FAILED" as const;
 export const FORGE_DB_OUTBOX_WRITE_FAILED = "FORGE_DB_OUTBOX_WRITE_FAILED" as const;
 export const FORGE_DB_ADAPTER_UNAVAILABLE = "FORGE_DB_ADAPTER_UNAVAILABLE" as const;
+export const FORGE_PGLITE_STORE_ABORTED = "FORGE_PGLITE_STORE_ABORTED" as const;
+export const FORGE_PGLITE_STORE_ACTIVE = "FORGE_PGLITE_STORE_ACTIVE" as const;
 export const FORGE_RLS_POLICY_MISSING = "FORGE_RLS_POLICY_MISSING" as const;
 export const FORGE_RLS_TENANT_FIELD_MISSING =
   "FORGE_RLS_TENANT_FIELD_MISSING" as const;
@@ -92,6 +107,8 @@ export const FORGE_RELEASE_DIRTY_WORKTREE =
 export const FORGE_RELEASE_GENERATED_DRIFT =
   "FORGE_RELEASE_GENERATED_DRIFT" as const;
 export const FORGE_RELEASE_ID_MISSING = "FORGE_RELEASE_ID_MISSING" as const;
+export const FORGE_RELEASE_PACKAGE_PACK_FAILED =
+  "FORGE_RELEASE_PACKAGE_PACK_FAILED" as const;
 export const FORGE_SOURCEMAP_PUBLIC_EXPOSURE =
   "FORGE_SOURCEMAP_PUBLIC_EXPOSURE" as const;
 export const FORGE_SOURCEMAP_UPLOAD_MISSING =
@@ -216,6 +233,8 @@ export const FORGE_TEST_DOCKER_REQUIRED = "FORGE_TEST_DOCKER_REQUIRED" as const;
 export const FORGE_TEST_BROWSER_REQUIRED = "FORGE_TEST_BROWSER_REQUIRED" as const;
 export const FORGE_VERIFY_CHANGED_INCOMPLETE =
   "FORGE_VERIFY_CHANGED_INCOMPLETE" as const;
+export const FORGE_VERIFY_NO_TESTS_SELECTED =
+  "FORGE_VERIFY_NO_TESTS_SELECTED" as const;
 export const FORGE_VERIFY_SCRIPT_TIMEOUT =
   "FORGE_VERIFY_SCRIPT_TIMEOUT" as const;
 export const FORGE_REPAIR_SOURCE_NOT_FOUND =
@@ -399,17 +418,26 @@ export const DIAGNOSTIC_CODES = [
   FORGE_RUNTIME_UNRESOLVABLE,
   FORGE_RUNTIME_NOT_FOUND,
   FORGE_RUNTIME_GUARD_BLOCKED,
+  FORGE_RUNTIME_EXPORT_NAME_REQUIRED,
+  FORGE_EXTERNAL_RUNTIME_NOT_FOUND,
+  FORGE_EXTERNAL_RUNTIME_UNSUPPORTED,
+  FORGE_EXTERNAL_RUNTIME_FAILED,
+  FORGE_EXTERNAL_RUNTIME_BAD_RESPONSE,
   FORGE_DEV_SERVER_ERROR,
   FORGE_DEV_WATCH_FAILED,
   FORGE_DEV_INVOKE_FAILED,
   FORGE_DEV_DOCTOR_MISSING_ARTIFACT,
+  FORGE_DEV_DB_RESET,
   FORGE_DB_CONNECT_FAILED,
   FORGE_DB_MIGRATION_FAILED,
   FORGE_DB_UNSUPPORTED_FIELD_TYPE,
   FORGE_DB_INVALID_SQL_PLAN,
+  FORGE_DB_EMPTY_TIMESTAMP_LITERAL,
   FORGE_DB_TRANSACTION_FAILED,
   FORGE_DB_OUTBOX_WRITE_FAILED,
   FORGE_DB_ADAPTER_UNAVAILABLE,
+  FORGE_PGLITE_STORE_ABORTED,
+  FORGE_PGLITE_STORE_ACTIVE,
   FORGE_RLS_POLICY_MISSING,
   FORGE_RLS_TENANT_FIELD_MISSING,
   FORGE_RLS_UNSUPPORTED_TENANT_TYPE,
@@ -444,6 +472,7 @@ export const DIAGNOSTIC_CODES = [
   FORGE_RELEASE_DIRTY_WORKTREE,
   FORGE_RELEASE_GENERATED_DRIFT,
   FORGE_RELEASE_ID_MISSING,
+  FORGE_RELEASE_PACKAGE_PACK_FAILED,
   FORGE_SOURCEMAP_PUBLIC_EXPOSURE,
   FORGE_SOURCEMAP_UPLOAD_MISSING,
   FORGE_SOURCEMAP_UPLOAD_FAILED,
@@ -521,6 +550,7 @@ export const DIAGNOSTIC_CODES = [
   FORGE_TEST_DOCKER_REQUIRED,
   FORGE_TEST_BROWSER_REQUIRED,
   FORGE_VERIFY_CHANGED_INCOMPLETE,
+  FORGE_VERIFY_NO_TESTS_SELECTED,
   FORGE_REPAIR_SOURCE_NOT_FOUND,
   FORGE_REPAIR_UNKNOWN_FAILURE,
   FORGE_REPAIR_NO_RULE_MATCHED,

package/src/forge/compiler/diagnostics/create.ts

@@ -47,9 +47,16 @@ function defaultGuidanceForCode(code: string): DiagnosticGuidance | null {
       docs: ["src/forge/_generated/runtimeRules.md", "AGENTS.md"],
     };
   }
+  if (code === "FORGE_RUNTIME_EXPORT_NAME_REQUIRED") {
+    return {
+      fixHint: "Forge runtime entries must be named exports. Replace `export default command(...)` with `export const createThing = command(...)` so generated API, frontend bindings, and capability maps have a stable name.",
+      suggestedCommands: ["forge check --json", "forge generate"],
+      docs: ["AGENTS.md", "src/forge/_generated/runtimeRules.md"],
+    };
+  }
   if (code === "FORGE_SECRET_DIRECT_PROCESS_ENV") {
     return {
-      fixHint: "Use ctx.secrets or ctx.config instead of reading process.env directly from app runtime code.",
+      fixHint: "Use ctx.secrets or ctx.config for Forge runtime secrets/config; public frontend bridge env may use the framework's public env surface.",
       suggestedCommands: ["forge repair diagnose --diagnostic FORGE_SECRET_DIRECT_PROCESS_ENV --json", "forge refactor replace-process-env <ENV_NAME> --dry-run --json"],
       docs: ["src/forge/_generated/runtimeRules.md"],
     };
@@ -75,6 +82,13 @@ function defaultGuidanceForCode(code: string): DiagnosticGuidance | null {
       docs: ["src/forge/_generated/agentContract.json"],
     };
   }
+  if (code === "FORGE_DB_EMPTY_TIMESTAMP_LITERAL") {
+    return {
+      fixHint: "Do not use an empty string for timestamp fields. Use a real ISO timestamp, omit an optional timestamp field, declare it as `timestamp?` / `nullable(\"timestamp\")`, or model it as text if empty string is meaningful.",
+      suggestedCommands: ["forge check --json", "forge dev --db pglite --once --json"],
+      docs: ["AGENTS.md"],
+    };
+  }
   if (code.startsWith("FORGE_UI_")) {
     return {
       fixHint: "Inspect the last UI run and use the UI report as repair input.",
@@ -106,7 +120,12 @@ function defaultGuidanceForCode(code: string): DiagnosticGuidance | null {
   if (code.startsWith("FORGE_FRONTEND_")) {
     return {
       fixHint: "Use the generated frontend bridge and inspect src/forge/_generated/frontendGraph.json before editing UI wiring.",
-      suggestedCommands: ["forge inspect frontend --json", "forge make ui --framework vite --dry-run --json", "forge generate"],
+      suggestedCommands: [
+        "forge inspect frontend --json",
+        "forge make ui --framework vite --dry-run --json",
+        "forge make ui --framework nuxt --dry-run --json",
+        "forge generate",
+      ],
       docs: ["src/forge/_generated/frontendGraph.json", "AGENTS.md"],
     };
   }

package/src/forge/compiler/diagnostics/index.ts

@@ -37,6 +37,8 @@ export {
   FORGE_LIVEQUERY_UNKNOWN,
   FORGE_LIVEQUERY_SUBSCRIPTION_FAILED,
   FORGE_LIVEQUERY_RERUN_FAILED,
+  FORGE_RELEASE_PACKAGE_PACK_FAILED,
+  FORGE_VERIFY_NO_TESTS_SELECTED,
   DIAGNOSTIC_CODES,
 } from "./codes.ts";
 export type { DiagnosticCode } from "./codes.ts";

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

@@ -33,6 +33,9 @@ export function buildBarrelIndexBody(exportFilePaths: string[]): string {
 
   const lines = unique.map((path) => {
     const exportPath = toBarrelExportPath(path);
+    if (exportPath === "./vue") {
+      return `export * as vue from "${exportPath}";`;
+    }
     return `export * from "${exportPath}";`;
   });
 

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

@@ -59,6 +59,7 @@ export function renderBody(file: EmitFile): string {
  */
 export function render(file: EmitFile, context: RenderContext): string {
   const body = renderBody(file);
+  const kind = detectArtifactKind(file.path);
 
   if (file.contentHash !== hashStable(body)) {
     throw new Error(
@@ -66,6 +67,14 @@ export function render(file: EmitFile, context: RenderContext): string {
     );
   }
 
+  if (kind === "json") {
+    return body;
+  }
+
+  if (file.header === "none") {
+    return body;
+  }
+
   return prependDeterministicHeader(body, {
     generatorVersion: context.generatorVersion,
     inputHash: context.inputHash,