forgeos 0.1.0-alpha.0

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

@@ -0,0 +1,390 @@
+import { createDiagnostic } from "../../diagnostics/create.ts";
+import {
+  FORGE_DB_INVALID_SQL_PLAN,
+  FORGE_DB_UNSUPPORTED_FIELD_TYPE,
+} from "../../diagnostics/codes.ts";
+import { hashStable } from "../../primitives/hash.ts";
+import { canonicalJson } from "../../primitives/serialize.ts";
+import type { DataField, DataGraph, DataTable } from "../../types/data-graph.ts";
+import type { Diagnostic } from "../../types/diagnostic.ts";
+import { quoteIdent, toSnakeCase } from "./naming.ts";
+import type { ColumnDef, IndexDef, SqlChange, SqlPlan } from "./types.ts";
+
+export const SQL_PLAN_SCHEMA_VERSION = "1.0.0";
+
+const SYSTEM_MIGRATIONS_SQL = `CREATE TABLE IF NOT EXISTS _forge_migrations (id text PRIMARY KEY, checksum text NOT NULL, applied_at timestamptz NOT NULL DEFAULT now())`;
+
+const SYSTEM_OUTBOX_SQL = `CREATE TABLE IF NOT EXISTS _forge_outbox (id bigserial PRIMARY KEY, event_type text NOT NULL, payload jsonb NOT NULL, auth_context jsonb, created_at timestamptz NOT NULL DEFAULT now())`;
+
+const SYSTEM_OUTBOX_DELIVERIES_SQL = `CREATE TABLE IF NOT EXISTS _forge_outbox_deliveries (id bigserial PRIMARY KEY, outbox_id bigint NOT NULL REFERENCES _forge_outbox(id), action_name text NOT NULL, status text NOT NULL DEFAULT 'pending', attempts integer NOT NULL DEFAULT 0, max_attempts integer NOT NULL DEFAULT 5, next_attempt_at timestamptz NOT NULL DEFAULT now(), locked_at timestamptz, locked_by text, last_error text, processed_at timestamptz, created_at timestamptz NOT NULL DEFAULT now(), UNIQUE(outbox_id, action_name))`;
+
+const SYSTEM_WORKFLOW_RUNS_SQL = `CREATE TABLE IF NOT EXISTS _forge_workflow_runs (id bigserial PRIMARY KEY, workflow_name text NOT NULL, trigger_type text NOT NULL, trigger_outbox_id bigint, idempotency_key text NOT NULL UNIQUE, input jsonb NOT NULL, auth_context jsonb, status text NOT NULL DEFAULT 'pending', current_step text, last_error text, created_at timestamptz NOT NULL DEFAULT now(), updated_at timestamptz NOT NULL DEFAULT now(), started_at timestamptz, completed_at timestamptz, canceled_at timestamptz)`;
+
+const SYSTEM_WORKFLOW_STEPS_SQL = `CREATE TABLE IF NOT EXISTS _forge_workflow_steps (id bigserial PRIMARY KEY, run_id bigint NOT NULL REFERENCES _forge_workflow_runs(id), step_name text NOT NULL, step_index integer NOT NULL, status text NOT NULL DEFAULT 'pending', input jsonb, output jsonb, attempts integer NOT NULL DEFAULT 0, max_attempts integer NOT NULL DEFAULT 5, next_attempt_at timestamptz NOT NULL DEFAULT now(), locked_at timestamptz, locked_by text, last_error text, started_at timestamptz, completed_at timestamptz, created_at timestamptz NOT NULL DEFAULT now(), UNIQUE(run_id, step_name))`;
+
+const SYSTEM_TELEMETRY_EVENTS_SQL = `CREATE TABLE IF NOT EXISTS _forge_telemetry_events (id bigserial PRIMARY KEY, trace_id text NOT NULL, event_type text NOT NULL, payload jsonb NOT NULL, status text NOT NULL DEFAULT 'pending', sink text, attempts integer NOT NULL DEFAULT 0, max_attempts integer NOT NULL DEFAULT 5, next_attempt_at timestamptz NOT NULL DEFAULT now(), last_error text, created_at timestamptz NOT NULL DEFAULT now(), processed_at timestamptz)`;
+
+const SYSTEM_TRACE_SPANS_SQL = `CREATE TABLE IF NOT EXISTS _forge_trace_spans (id bigserial PRIMARY KEY, trace_id text NOT NULL, parent_span_id text, span_id text NOT NULL, name text NOT NULL, kind text NOT NULL, attributes jsonb NOT NULL DEFAULT '{}', status text NOT NULL DEFAULT 'ok', started_at timestamptz NOT NULL, ended_at timestamptz, error text)`;
+
+const SYSTEM_LIVE_REVISION_SEQUENCE_SQL = `CREATE SEQUENCE IF NOT EXISTS _forge_live_revision_seq START WITH 2`;
+
+const SYSTEM_LIVE_INVALIDATIONS_SQL = `CREATE TABLE IF NOT EXISTS _forge_live_invalidations (id bigserial PRIMARY KEY, revision bigint NOT NULL, table_name text NOT NULL, tenant_id text, operation text NOT NULL, source_kind text NOT NULL, source_name text, trace_id text, release_id text, deploy_id text, payload jsonb NOT NULL DEFAULT '{}', created_at timestamptz NOT NULL DEFAULT now())`;
+
+const SYSTEM_LIVE_SUBSCRIPTION_DEBUG_SQL = `CREATE TABLE IF NOT EXISTS _forge_live_subscription_debug (id text PRIMARY KEY, name text NOT NULL, tenant_id text, dependencies jsonb NOT NULL, last_revision bigint, runtime_id text, created_at timestamptz NOT NULL DEFAULT now(), updated_at timestamptz NOT NULL DEFAULT now())`;
+
+interface ParsedFieldType {
+  sqlType: string;
+  references?: { table: string; column: string };
+  checkConstraint?: string;
+}
+
+function stableSortTables(tables: DataTable[]): DataTable[] {
+  return [...tables].sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
+}
+
+function parseFieldType(
+  field: DataField,
+  tableName: string,
+  diagnostics: Diagnostic[],
+): ParsedFieldType | null {
+  const raw = field.type.trim().toLowerCase();
+
+  if (raw === "uuid") {
+    return { sqlType: "uuid" };
+  }
+  if (raw === "text" || raw === "string") {
+    return { sqlType: "text" };
+  }
+  if (raw === "number") {
+    return { sqlType: "double precision" };
+  }
+  if (raw === "integer" || raw === "int") {
+    return { sqlType: "integer" };
+  }
+  if (raw === "boolean" || raw === "bool") {
+    return { sqlType: "boolean" };
+  }
+  if (raw === "timestamp") {
+    return { sqlType: "timestamptz" };
+  }
+  if (raw === "json") {
+    return { sqlType: "jsonb" };
+  }
+
+  if (raw.startsWith("enum:")) {
+    const values = raw
+      .slice("enum:".length)
+      .split(",")
+      .map((value) => value.trim())
+      .filter(Boolean);
+    if (values.length === 0) {
+      diagnostics.push(
+        createDiagnostic({
+          severity: "error",
+          code: FORGE_DB_UNSUPPORTED_FIELD_TYPE,
+          message: `unsupported enum field type '${field.type}' on ${tableName}.${field.name}`,
+        }),
+      );
+      return null;
+    }
+    const checkValues = values.map((value) => `'${value.replace(/'/g, "''")}'`).join(", ");
+    return {
+      sqlType: "text",
+      checkConstraint: `${quoteIdent(toSnakeCase(field.name))} IN (${checkValues})`,
+    };
+  }
+
+  if (raw.startsWith("enum_")) {
+    return { sqlType: "text" };
+  }
+
+  if (raw.startsWith("ref:")) {
+    const refTable = raw.slice("ref:".length).trim();
+    if (!refTable) {
+      diagnostics.push(
+        createDiagnostic({
+          severity: "error",
+          code: FORGE_DB_UNSUPPORTED_FIELD_TYPE,
+          message: `invalid ref field type '${field.type}' on ${tableName}.${field.name}`,
+        }),
+      );
+      return null;
+    }
+    return {
+      sqlType: "uuid",
+      references: { table: toSnakeCase(refTable), column: "id" },
+    };
+  }
+
+  if (raw === "ref") {
+    return {
+      sqlType: "uuid",
+      references: { table: toSnakeCase(field.name.replace(/Id$/i, "")), column: "id" },
+    };
+  }
+
+  diagnostics.push(
+    createDiagnostic({
+      severity: "error",
+      code: FORGE_DB_UNSUPPORTED_FIELD_TYPE,
+      message: `unsupported field type '${field.type}' on ${tableName}.${field.name}`,
+    }),
+  );
+  return null;
+}
+
+function defaultExprForField(field: DataField): string | undefined {
+  const name = field.name;
+  const type = field.type.trim().toLowerCase();
+
+  if (name === "id" && type === "uuid") {
+    return "gen_random_uuid()";
+  }
+
+  if (
+    (name === "createdAt" || name === "updatedAt") &&
+    (type === "timestamp" || type === "timestamptz")
+  ) {
+    return "now()";
+  }
+
+  return undefined;
+}
+
+function buildColumns(table: DataTable, diagnostics: Diagnostic[]): ColumnDef[] {
+  const columns: ColumnDef[] = [];
+  const fields = [...table.fields].sort((a, b) =>
+    a.name < b.name ? -1 : a.name > b.name ? 1 : 0,
+  );
+
+  const hasIdField = fields.some((field) => field.name === "id");
+  if (!hasIdField) {
+    columns.push({
+      name: "id",
+      fieldName: "id",
+      sqlType: "uuid",
+      nullable: false,
+      primaryKey: true,
+      defaultExpr: "gen_random_uuid()",
+    });
+  }
+
+  for (const field of fields) {
+    const parsed = parseFieldType(field, table.name, diagnostics);
+    if (!parsed) {
+      continue;
+    }
+
+    const snakeName = toSnakeCase(field.name);
+    const defaultExpr = defaultExprForField(field);
+    const isPrimaryKey = field.name === "id" && parsed.sqlType === "uuid";
+
+    columns.push({
+      name: snakeName,
+      fieldName: field.name,
+      sqlType: parsed.sqlType,
+      nullable: false,
+      primaryKey: isPrimaryKey,
+      defaultExpr,
+      references: parsed.references,
+      checkConstraint: parsed.checkConstraint,
+    });
+  }
+
+  if (!columns.some((column) => column.primaryKey) && columns.length > 0) {
+    columns[0]!.primaryKey = true;
+  }
+
+  return columns;
+}
+
+function renderColumn(column: ColumnDef): string {
+  const parts = [
+    quoteIdent(column.name),
+    column.sqlType,
+    column.nullable ? "" : "NOT NULL",
+    column.defaultExpr ? `DEFAULT ${column.defaultExpr}` : "",
+    column.primaryKey ? "PRIMARY KEY" : "",
+    column.references
+      ? `REFERENCES ${quoteIdent(column.references.table)} (${quoteIdent(column.references.column)})`
+      : "",
+    column.checkConstraint ? `CHECK (${column.checkConstraint})` : "",
+  ].filter((part) => part.length > 0);
+
+  return parts.join(" ");
+}
+
+function buildCreateTableSql(tableName: string, columns: ColumnDef[]): string {
+  const rendered = columns.map(renderColumn).join(", ");
+  return `CREATE TABLE IF NOT EXISTS ${quoteIdent(tableName)} (${rendered})`;
+}
+
+function buildForeignKeyIndexes(tableName: string, columns: ColumnDef[]): IndexDef[] {
+  const indexes: IndexDef[] = [];
+
+  for (const column of columns) {
+    if (column.references) {
+      indexes.push({
+        name: `idx_${tableName}_${column.name}`,
+        table: tableName,
+        columns: [column.name],
+      });
+    }
+  }
+
+  return indexes;
+}
+
+function buildTableChange(table: DataTable, diagnostics: Diagnostic[]): SqlChange | null {
+  const tableName = toSnakeCase(table.name);
+  const columns = buildColumns(table, diagnostics);
+
+  if (columns.length === 0) {
+    diagnostics.push(
+      createDiagnostic({
+        severity: "error",
+        code: FORGE_DB_INVALID_SQL_PLAN,
+        message: `table '${table.name}' has no valid columns`,
+        file: table.file,
+      }),
+    );
+    return null;
+  }
+
+  return {
+    kind: "create_table",
+    table: tableName,
+    columns,
+    sql: buildCreateTableSql(tableName, columns),
+  };
+}
+
+function buildIndexChange(index: IndexDef): SqlChange {
+  const columns = index.columns.map(quoteIdent).join(", ");
+  const unique = index.unique ? "UNIQUE " : "";
+  return {
+    kind: "create_index",
+    table: index.table,
+    index,
+    sql: `CREATE INDEX IF NOT EXISTS ${quoteIdent(index.name)} ON ${quoteIdent(index.table)} ${unique}(${columns})`,
+  };
+}
+
+export function buildSqlPlan(dataGraph: DataGraph): SqlPlan {
+  const diagnostics: Diagnostic[] = [];
+  const tables: SqlChange[] = [];
+  const indexes: SqlChange[] = [];
+
+  const systemTables: SqlChange[] = [
+    {
+      kind: "create_table",
+      table: "_forge_migrations",
+      sql: SYSTEM_MIGRATIONS_SQL,
+    },
+    {
+      kind: "create_table",
+      table: "_forge_outbox",
+      sql: SYSTEM_OUTBOX_SQL,
+    },
+    {
+      kind: "create_table",
+      table: "_forge_outbox_deliveries",
+      sql: SYSTEM_OUTBOX_DELIVERIES_SQL,
+    },
+    {
+      kind: "create_table",
+      table: "_forge_workflow_runs",
+      sql: SYSTEM_WORKFLOW_RUNS_SQL,
+    },
+    {
+      kind: "create_table",
+      table: "_forge_workflow_steps",
+      sql: SYSTEM_WORKFLOW_STEPS_SQL,
+    },
+    {
+      kind: "create_table",
+      table: "_forge_telemetry_events",
+      sql: SYSTEM_TELEMETRY_EVENTS_SQL,
+    },
+    {
+      kind: "create_table",
+      table: "_forge_trace_spans",
+      sql: SYSTEM_TRACE_SPANS_SQL,
+    },
+    {
+      kind: "create_sequence",
+      table: "_forge_live_revision_seq",
+      sql: SYSTEM_LIVE_REVISION_SEQUENCE_SQL,
+    },
+    {
+      kind: "create_table",
+      table: "_forge_live_invalidations",
+      sql: SYSTEM_LIVE_INVALIDATIONS_SQL,
+    },
+    {
+      kind: "create_table",
+      table: "_forge_live_subscription_debug",
+      sql: SYSTEM_LIVE_SUBSCRIPTION_DEBUG_SQL,
+    },
+  ];
+
+  for (const table of stableSortTables(dataGraph.tables)) {
+    const change = buildTableChange(table, diagnostics);
+    if (!change) {
+      continue;
+    }
+    tables.push(change);
+
+    if (change.columns) {
+      for (const index of buildForeignKeyIndexes(change.table!, change.columns)) {
+        indexes.push(buildIndexChange(index));
+      }
+    }
+  }
+
+  indexes.sort((a, b) => {
+    const nameA = a.index?.name ?? "";
+    const nameB = b.index?.name ?? "";
+    return nameA < nameB ? -1 : nameA > nameB ? 1 : 0;
+  });
+
+  indexes.push(
+    buildIndexChange({
+      name: "forge_live_invalidations_revision_idx",
+      table: "_forge_live_invalidations",
+      columns: ["revision"],
+    }),
+    buildIndexChange({
+      name: "forge_live_invalidations_table_tenant_revision_idx",
+      table: "_forge_live_invalidations",
+      columns: ["table_name", "tenant_id", "revision"],
+    }),
+  );
+
+  const payload = {
+    schemaVersion: SQL_PLAN_SCHEMA_VERSION,
+    systemTables: systemTables.map((change) => change.sql),
+    tables: tables.map((change) => change.sql),
+    indexes: indexes.map((change) => change.sql),
+  };
+
+  const checksum = hashStable(canonicalJson(payload));
+  const migrationId = `migration_${checksum.slice(0, 16)}`;
+
+  return {
+    schemaVersion: SQL_PLAN_SCHEMA_VERSION,
+    migrationId,
+    checksum,
+    systemTables,
+    tables,
+    indexes,
+    diagnostics: diagnostics.sort((a, b) => {
+      const fileA = a.file ?? "";
+      const fileB = b.file ?? "";
+      if (fileA !== fileB) {
+        return fileA < fileB ? -1 : 1;
+      }
+      return a.message < b.message ? -1 : a.message > b.message ? 1 : 0;
+    }),
+  };
+}

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

@@ -0,0 +1,10 @@
+export function toSnakeCase(name: string): string {
+  return name
+    .replace(/([a-z0-9])([A-Z])/g, "$1_$2")
+    .replace(/[-\s]+/g, "_")
+    .toLowerCase();
+}
+
+export function quoteIdent(ident: string): string {
+  return `"${ident.replace(/"/g, '""')}"`;
+}

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

@@ -0,0 +1,85 @@
+import { serializeCanonical } from "../../primitives/serialize.ts";
+import type { SqlPlan } from "./types.ts";
+import type { TenantScope } from "../../types/policy-registry.ts";
+
+export function serializeSqlPlanJson(plan: SqlPlan): string {
+  const payload = {
+    schemaVersion: plan.schemaVersion,
+    migrationId: plan.migrationId,
+    checksum: plan.checksum,
+    systemTables: plan.systemTables.map((change) => ({
+      kind: change.kind,
+      table: change.table,
+      sql: change.sql,
+    })),
+    tables: plan.tables.map((change) => ({
+      kind: change.kind,
+      table: change.table,
+      columns: change.columns,
+      sql: change.sql,
+    })),
+    indexes: plan.indexes.map((change) => ({
+      kind: change.kind,
+      table: change.table,
+      index: change.index,
+      sql: change.sql,
+    })),
+    diagnostics: plan.diagnostics,
+  };
+  return serializeCanonical(payload);
+}
+
+export function serializeSqlPlanTs(plan: SqlPlan): string {
+  const parsed: unknown = JSON.parse(serializeSqlPlanJson(plan).trimEnd());
+  return `export const sqlPlan = ${JSON.stringify(parsed, null, 2)} as const;\n`;
+}
+
+export interface TableMapEntry {
+  tableName: string;
+  columns: { name: string; fieldName?: string; sqlType: string; primaryKey?: boolean }[];
+  tenantScoped?: boolean;
+  tenantIdColumn?: string;
+}
+
+export function buildTableMap(
+  plan: SqlPlan,
+  tenantScope?: TenantScope,
+): Record<string, TableMapEntry> {
+  const map: Record<string, TableMapEntry> = {};
+  const scopeByTable = new Map(
+    (tenantScope?.tables ?? []).map((entry) => [entry.table, entry.tenantIdColumn]),
+  );
+
+  for (const change of plan.tables) {
+    if (!change.table || !change.columns) {
+      continue;
+    }
+    const tenantIdColumn = scopeByTable.get(change.table);
+    map[change.table] = {
+      tableName: change.table,
+      columns: change.columns.map((column) => ({
+        name: column.name,
+        ...(column.fieldName && column.fieldName !== column.name
+          ? { fieldName: column.fieldName }
+          : {}),
+        sqlType: column.sqlType,
+        ...(column.primaryKey ? { primaryKey: true } : {}),
+      })),
+      ...(tenantIdColumn
+        ? { tenantScoped: true, tenantIdColumn }
+        : {}),
+    };
+  }
+
+  return map;
+}
+
+export function serializeDbJson(plan: SqlPlan, tenantScope?: TenantScope): string {
+  const tableMap = buildTableMap(plan, tenantScope);
+  return serializeCanonical({ tableMap });
+}
+
+export function serializeDbTs(plan: SqlPlan, tenantScope?: TenantScope): string {
+  const tableMap = buildTableMap(plan, tenantScope);
+  return `export const tableMap = ${JSON.stringify(tableMap, null, 2)} as const;\n`;
+}

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

@@ -0,0 +1,37 @@
+import type { Diagnostic } from "../../types/diagnostic.ts";
+
+export interface ColumnDef {
+  name: string;
+  fieldName?: string;
+  sqlType: string;
+  nullable: boolean;
+  primaryKey?: boolean;
+  defaultExpr?: string;
+  references?: { table: string; column: string };
+  checkConstraint?: string;
+}
+
+export interface IndexDef {
+  name: string;
+  table: string;
+  columns: string[];
+  unique?: boolean;
+}
+
+export interface SqlChange {
+  kind: "create_table" | "create_index" | "create_sequence";
+  table?: string;
+  columns?: ColumnDef[];
+  index?: IndexDef;
+  sql: string;
+}
+
+export interface SqlPlan {
+  schemaVersion: string;
+  migrationId: string;
+  checksum: string;
+  systemTables: SqlChange[];
+  tables: SqlChange[];
+  indexes: SqlChange[];
+  diagnostics: Diagnostic[];
+}

package/src/forge/compiler/dev-manifest/build.ts

@@ -0,0 +1,170 @@
+import { GENERATOR_VERSION } from "../emitter/constants.ts";
+import { hashStable } from "../primitives/hash.ts";
+import { canonicalJson } from "../primitives/serialize.ts";
+import type { AppGraph } from "../types/app-graph.ts";
+import type {
+  DevManifest,
+  DevManifestEntry,
+  DevManifestWorkflow,
+  DevRoute,
+} from "../types/dev-manifest.ts";
+import type { RuntimeGraph } from "../types/runtime-graph.ts";
+import type { QueryRegistry } from "../types/query-registry.ts";
+import {
+  DEV_MANIFEST_ANALYZER_VERSION,
+  DEV_MANIFEST_SCHEMA_VERSION,
+} from "./constants.ts";
+
+function stableSortRoutes(routes: DevRoute[]): DevRoute[] {
+  return [...routes].sort((a, b) => {
+    if (a.path !== b.path) {
+      return a.path < b.path ? -1 : 1;
+    }
+    if (a.method !== b.method) {
+      return a.method < b.method ? -1 : 1;
+    }
+    const nameA = a.entryName ?? "";
+    const nameB = b.entryName ?? "";
+    if (nameA !== nameB) {
+      return nameA < nameB ? -1 : 1;
+    }
+    return 0;
+  });
+}
+
+function stableSortEntries(entries: DevManifestEntry[]): DevManifestEntry[] {
+  return [...entries].sort((a, b) => {
+    if (a.name !== b.name) {
+      return a.name < b.name ? -1 : 1;
+    }
+    return a.kind < b.kind ? -1 : a.kind > b.kind ? 1 : 0;
+  });
+}
+
+function stableSortWorkflows(
+  workflows: DevManifestWorkflow[],
+): DevManifestWorkflow[] {
+  return [...workflows].sort((a, b) => {
+    if (a.name !== b.name) {
+      return a.name < b.name ? -1 : 1;
+    }
+    return a.file < b.file ? -1 : a.file > b.file ? 1 : 0;
+  });
+}
+
+function buildRoutes(
+  runtimeGraph: RuntimeGraph,
+  queryRegistry: QueryRegistry,
+): DevRoute[] {
+  const routes: DevRoute[] = [
+    { method: "GET", path: "/", purpose: "home" },
+    { method: "GET", path: "/health", purpose: "health" },
+    { method: "GET", path: "/entries", purpose: "entries" },
+    { method: "GET", path: "/queries", purpose: "queries" },
+    { method: "GET", path: "/workflows", purpose: "workflows" },
+    { method: "GET", path: "/workflows/runs", purpose: "workflow-runs" },
+    { method: "POST", path: "/workflows/process", purpose: "workflow-process" },
+  ];
+
+  for (const query of queryRegistry.queries) {
+    routes.push({
+      method: "POST",
+      path: `/queries/${query.name}`,
+      purpose: "query",
+      entryName: query.name,
+      entryKind: "query",
+    });
+  }
+
+  for (const entry of runtimeGraph.entries) {
+    routes.push({
+      method: "POST",
+      path: `/run/${entry.name}`,
+      purpose: "invoke",
+      entryName: entry.name,
+      entryKind: entry.kind,
+    });
+
+    if (entry.kind === "command") {
+      routes.push({
+        method: "POST",
+        path: `/commands/${entry.name}`,
+        purpose: "invoke",
+        entryName: entry.name,
+        entryKind: "command",
+      });
+    } else {
+      routes.push({
+        method: "POST",
+        path: `/actions/${entry.name}`,
+        purpose: "invoke",
+        entryName: entry.name,
+        entryKind: "action",
+      });
+    }
+  }
+
+  return stableSortRoutes(routes);
+}
+
+function buildEntries(
+  runtimeGraph: RuntimeGraph,
+  queryRegistry: QueryRegistry,
+): DevManifestEntry[] {
+  const queryEntries = queryRegistry.queries.map((query) => ({
+    name: query.name,
+    kind: "query" as const,
+    invokePath: `/queries/${query.name}`,
+    semanticPath: `/queries/${query.name}`,
+  }));
+
+  const entries = runtimeGraph.entries.map((entry) => ({
+    name: entry.name,
+    kind: entry.kind,
+    invokePath: `/run/${entry.name}`,
+    semanticPath:
+      entry.kind === "command"
+        ? `/commands/${entry.name}`
+        : `/actions/${entry.name}`,
+  }));
+
+  return stableSortEntries([...queryEntries, ...entries]);
+}
+
+function buildWorkflows(appGraph?: AppGraph): DevManifestWorkflow[] {
+  if (!appGraph) {
+    return [];
+  }
+
+  const workflows = appGraph.symbols
+    .filter((symbol) => symbol.kind === "workflow")
+    .map((symbol) => ({
+      name: symbol.name,
+      file: symbol.file,
+    }));
+
+  return stableSortWorkflows(workflows);
+}
+
+export function buildDevManifest(
+  runtimeGraph: RuntimeGraph,
+  queryRegistry: QueryRegistry,
+  appGraph?: AppGraph,
+): DevManifest {
+  return {
+    schemaVersion: DEV_MANIFEST_SCHEMA_VERSION,
+    generatorVersion: GENERATOR_VERSION,
+    analyzerVersion: DEV_MANIFEST_ANALYZER_VERSION,
+    inputHash: hashStable(
+      canonicalJson({
+        runtimeInputHash: runtimeGraph.inputHash,
+        queryInputHash: queryRegistry.inputHash,
+        analyzerVersion: DEV_MANIFEST_ANALYZER_VERSION,
+      }),
+    ),
+    routes: buildRoutes(runtimeGraph, queryRegistry),
+    entries: buildEntries(runtimeGraph, queryRegistry),
+    workflows: buildWorkflows(appGraph),
+    diagnostics: [...runtimeGraph.diagnostics, ...queryRegistry.diagnostics],
+  };
+}

package/src/forge/compiler/dev-manifest/constants.ts

@@ -0,0 +1,5 @@
+/** DevManifest model schema version. */
+export const DEV_MANIFEST_SCHEMA_VERSION = "1.0.0";
+
+/** DevManifest route / analyzer version. */
+export const DEV_MANIFEST_ANALYZER_VERSION = "0.1.0";