From 740bbc7affb5ef1fd6586c0affb87bba451e52b7 Mon Sep 17 00:00:00 2001
From: "Timothy J. Aveni" <tja@berkeley.edu>
Date: Mon, 13 Jul 2026 21:49:18 -0700
Subject: [PATCH] Move Camino package codegen into package runtime

---
 .yarn/install-state.gz    | Bin 8348 -> 13737 bytes
 flake.lock                |  10 +-
 flake.nix                 |   2 +-
 package.json              |   6 +-
 src/codegen-ts-runtime.ts | 414 +++++++++++++++++++
 src/schema-compiler.ts    | 809 ++++++++++++++++++++++++++++++++++++++
 src/schema-ir.ts          | 148 +++++++
 yarn-project.nix          |  13 +
 yarn.lock                 | 110 ++++++
 9 files changed, 1505 insertions(+), 7 deletions(-)
 create mode 100644 src/codegen-ts-runtime.ts
 create mode 100644 src/schema-compiler.ts
 create mode 100644 src/schema-ir.ts

diff --git a/.yarn/install-state.gz b/.yarn/install-state.gz
index 93cecc4f2cd532b3538459aec7869b59b2b5b10f..5b4694f3804f22899d66d098522e168166960522 100644
GIT binary patch
literal 13737
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
P|F>VDsd}hggOLFMfGcDo

literal 8348
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

diff --git a/flake.lock b/flake.lock
index 0c6f604..f465e25 100644
--- a/flake.lock
+++ b/flake.lock
@@ -74,17 +74,17 @@
         "nixpkgs": "nixpkgs_2"
       },
       "locked": {
-        "lastModified": 1783905858,
-        "narHash": "sha256-R8q7hiklpUmKUDs6DCglEsI21CYnMxydZHv9+xq7hj4=",
+        "lastModified": 1783954303,
+        "narHash": "sha256-xywk5pWpvOD2rWmNaZ3arYgkx3Km/qsos4g1uB2pXVA=",
         "ref": "refs/heads/exported",
-        "rev": "c5141a24c4e82672d66d4b45ac11c45d7d88e1f7",
-        "revCount": 10,
+        "rev": "ff07b0d7933ad01c0b52bae2dcab1445e8e91eeb",
+        "revCount": 14,
         "type": "git",
         "url": "https://gitea-external.egads.tutti.syntaxblitz.net/quixos/quixos-protocol.git"
       },
       "original": {
         "ref": "refs/heads/exported",
-        "rev": "c5141a24c4e82672d66d4b45ac11c45d7d88e1f7",
+        "rev": "ff07b0d7933ad01c0b52bae2dcab1445e8e91eeb",
         "type": "git",
         "url": "https://gitea-external.egads.tutti.syntaxblitz.net/quixos/quixos-protocol.git"
       }
diff --git a/flake.nix b/flake.nix
index 6d3043c..a89aee2 100644
--- a/flake.nix
+++ b/flake.nix
@@ -4,7 +4,7 @@
   inputs = {
     nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
     flake-utils.url = "github:numtide/flake-utils";
-    quixos-protocol.url = "git+https://gitea-external.egads.tutti.syntaxblitz.net/quixos/quixos-protocol.git?ref=refs/heads/exported&rev=c5141a24c4e82672d66d4b45ac11c45d7d88e1f7";
+    quixos-protocol.url = "git+https://gitea-external.egads.tutti.syntaxblitz.net/quixos/quixos-protocol.git?ref=refs/heads/exported&rev=ff07b0d7933ad01c0b52bae2dcab1445e8e91eeb";
     quixosNixHelpers = {
       url = "git+https://gitea-external.egads.tutti.syntaxblitz.net/quixos/quixos-nix-helpers.git?ref=refs/heads/exported&rev=1f0c39b01501d646fe97dfc6e5777ccab0bde2f1";
       flake = false;
diff --git a/package.json b/package.json
index 1cc9c5e..eaa6c54 100644
--- a/package.json
+++ b/package.json
@@ -4,6 +4,9 @@
   "private": true,
   "packageManager": "yarn@4.14.1",
   "type": "module",
+  "bin": {
+    "camino-codegen-ts-runtime": "dist/src/codegen-ts-runtime.js"
+  },
   "exports": {
     ".": {
       "types": "./src/index.ts",
@@ -20,7 +23,8 @@
     "@bufbuild/protobuf": "^2.12.1",
     "@connectrpc/connect": "^2.1.2",
     "@connectrpc/connect-node": "^2.1.2",
-    "@quixos/camino-datatypes": "https://gitea-external.egads.tutti.syntaxblitz.net/quixos/camino-datatypes.git#commit=e061e290709c672d2dc675e5c871733de195211a"
+    "@quixos/camino-datatypes": "https://gitea-external.egads.tutti.syntaxblitz.net/quixos/camino-datatypes.git#commit=e061e290709c672d2dc675e5c871733de195211a",
+    "protobufjs": "^7.5.4"
   },
   "devDependencies": {
     "@bufbuild/protoc-gen-es": "^2.12.1",
diff --git a/src/codegen-ts-runtime.ts b/src/codegen-ts-runtime.ts
new file mode 100644
index 0000000..d14508f
--- /dev/null
+++ b/src/codegen-ts-runtime.ts
@@ -0,0 +1,414 @@
+#!/usr/bin/env node
+import fs from "node:fs";
+import path from "node:path";
+import { compileCaminoSchema } from "./schema-compiler.js";
+import type {
+  ClassSchema,
+  FieldSchema,
+  FunctionRef,
+  InterfaceImplementation,
+  TypeRef,
+} from "./schema-ir.js";
+
+const usage = (): never => {
+  console.error(
+    "Usage: camino-codegen-ts-runtime <class-schema.camino.proto> <out-dir> [implementation-import]",
+  );
+  process.exit(1);
+};
+
+const required = (value: string | undefined) => value ?? usage();
+
+const stringLiteral = (value: string) => JSON.stringify(value);
+
+const upperFirst = (value: string) =>
+  value.length === 0 ? value : `${value[0]?.toUpperCase()}${value.slice(1)}`;
+
+const lowerFirst = (value: string) =>
+  value.length === 0 ? value : `${value[0]?.toLowerCase()}${value.slice(1)}`;
+
+const camel = (value: string) =>
+  value
+    .split(/[^a-zA-Z0-9]+/)
+    .filter(Boolean)
+    .map((part, index) =>
+      index === 0 ? lowerFirst(part) : upperFirst(lowerFirst(part)),
+    )
+    .join("");
+
+const isIdentifier = (value: string) => /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(value);
+
+const classId = (schema: ClassSchema) =>
+  `${schema.id.namespace}:${schema.id.name}:${schema.id.version}:${
+    schema.id.hash ?? ""
+  }`;
+
+const symbolId = (value: { namespace: string; name: string; version: string; hash?: string }) =>
+  `${value.namespace}:${value.name}:${value.version}:${value.hash ?? ""}`;
+
+const tsTypeForTypeRef = (type: TypeRef): string => {
+  if (type.enumValues && type.enumValues.length > 0) {
+    return type.enumValues.map(stringLiteral).join(" | ");
+  }
+  switch (type.protoType.replace(/^\./, "")) {
+    case "string":
+    case "google.protobuf.StringValue":
+      return "string";
+    case "bool":
+    case "google.protobuf.BoolValue":
+      return "boolean";
+    case "double":
+    case "float":
+    case "google.protobuf.DoubleValue":
+    case "google.protobuf.FloatValue":
+    case "int32":
+    case "sint32":
+    case "sfixed32":
+    case "uint32":
+    case "fixed32":
+    case "int64":
+    case "sint64":
+    case "sfixed64":
+    case "uint64":
+    case "fixed64":
+    case "google.protobuf.Int32Value":
+    case "google.protobuf.UInt32Value":
+    case "google.protobuf.Int64Value":
+    case "google.protobuf.UInt64Value":
+      return "number";
+    case "bytes":
+    case "google.protobuf.BytesValue":
+      return "Uint8Array";
+    default:
+      return "unknown";
+  }
+};
+
+const tsTypeForField = (field: FieldSchema): string => tsTypeForTypeRef(field.type);
+
+const tsValueTypeForField = (field: FieldSchema) =>
+  field.repeated ? `${tsTypeForField(field)}[]` : tsTypeForField(field);
+
+const tsFieldApiType = (field: FieldSchema) =>
+  field.conflict === "crdt"
+    ? `CrdtField<${tsValueTypeForField(field)}>`
+    : `Field<${tsValueTypeForField(field)}>`;
+
+const functionExportName = (fn: FunctionRef, fallback: string) => {
+  if (isIdentifier(fn.symbol)) {
+    return fn.symbol;
+  }
+  const fallbackName = camel(fallback);
+  if (isIdentifier(fallbackName)) {
+    return fallbackName;
+  }
+  throw new Error(`Cannot generate TS export name for function ${fn.symbol}`);
+};
+
+const generatedWarning = `// @generated by camino-codegen-ts-runtime. Do not edit.\n`;
+
+type FunctionSpec = {
+  exportName: string;
+  symbol: string;
+  operation?: string;
+  packageNamespace: string;
+  packageName: string;
+  field?: {
+    name: string;
+    type: string;
+    storage: string;
+    conflict: string;
+  };
+};
+
+const fieldTypeId = (field: FieldSchema) =>
+  field.type.symbol ? symbolId(field.type.symbol) : field.type.protoType;
+
+const crdtStorageTypeId = (field: FieldSchema) =>
+  field.type.protoType ||
+  (field.type.symbol
+    ? `${field.type.symbol.namespace}.${field.type.symbol.name}`
+    : fieldTypeId(field));
+
+const fieldStorageId = (field: FieldSchema) =>
+  field.ops && field.storage.kind === "stored" ? "derived" : field.storage.kind;
+
+const interfaceTypeName = (implementation: InterfaceImplementation) =>
+  `${implementation.interface.name}Ref`;
+
+const renderInterfaceRefTypes = (schema: ClassSchema) =>
+  schema.implements
+    .map((implementation) => {
+      const typeParams = implementation.typeBindings.map((binding) => binding.name);
+      const generic =
+        typeParams.length > 0 ? `<${typeParams.join(", ")}>` : "";
+      const bindings =
+        typeParams.length > 0
+          ? typeParams
+              .map((param) => `      readonly ${param}: ${param};`)
+              .join("\n")
+          : "      readonly value: unknown;";
+      return `export type ${interfaceTypeName(implementation)}${generic} = ObjectRef<string> & {
+  readonly $caminoInterfaces: {
+    readonly ${stringLiteral(symbolId(implementation.interface))}: {
+${bindings}
+    };
+  };
+};`;
+    })
+    .join("\n\n");
+
+const interfaceMixins = (schema: ClassSchema) =>
+  schema.implements.map((implementation) => {
+    const typeArgs = implementation.typeBindings.map((binding) =>
+      tsTypeForTypeRef(binding.type),
+    );
+    return `${interfaceTypeName(implementation)}${
+      typeArgs.length > 0 ? `<${typeArgs.join(", ")}>` : ""
+    }`;
+  });
+
+const operationFunctionSpecs = (schema: ClassSchema): FunctionSpec[] =>
+  schema.fields.flatMap((field) => {
+    const serviceName = field.ops?.service.replace(/^\./, "");
+    if (!serviceName) {
+      return [];
+    }
+    const service = schema.operationServices.find(
+      (candidate) => candidate.fullName === serviceName,
+    );
+    if (!service) {
+      throw new Error(
+        `${schema.id.name}.${field.name} points to missing operation service ${field.ops?.service}`,
+      );
+    }
+    return service.operations.map((operation) => ({
+      exportName: functionExportName(
+        operation.function,
+        `${field.name}_${operation.name}`,
+      ),
+      symbol: operation.function.symbol,
+      ...(operation.function.operation
+        ? { operation: operation.function.operation }
+        : {}),
+      packageNamespace: operation.function.packageNamespace,
+      packageName: operation.function.packageName,
+      field: {
+        name: field.name,
+        type: fieldTypeId(field),
+        storage: fieldStorageId(field),
+        conflict: field.conflict,
+      },
+    }));
+  });
+
+const renderRuntime = (schema: ClassSchema) => {
+  const className = schema.id.name;
+  const objectTypeName = `${className}Object`;
+  const refTypeName = `${className}Ref`;
+  const contextTypeName = `${className}Context`;
+  const implementationTypeName = `${className}Implementation`;
+  const serveName = `serve${className}Runtime`;
+  const createObjectName = `create${className}Object`;
+  const interfaceRefTypes = renderInterfaceRefTypes(schema);
+  const refType =
+    [ `ObjectRef<${stringLiteral(classId(schema))}>`, ...interfaceMixins(schema)]
+      .join(" & ");
+  const edgeFields = new Set(schema.edges.map((edge) => edge.sourceField));
+  const writableFields = schema.fields.filter(
+    (field) =>
+      field.storage.kind === "stored" &&
+      !field.ops &&
+      !edgeFields.has(field.name),
+  );
+  const functionSpecs = [
+    ...(schema.constructorSpec
+      ? [
+          {
+            exportName: functionExportName(
+              schema.constructorSpec.function,
+              "constructor",
+            ),
+            symbol: schema.constructorSpec.function.symbol,
+            ...(schema.constructorSpec.function.operation
+              ? { operation: schema.constructorSpec.function.operation }
+              : {}),
+            packageNamespace: schema.constructorSpec.function.packageNamespace,
+            packageName: schema.constructorSpec.function.packageName,
+          },
+        ]
+      : []),
+    ...schema.methods.map((method) => ({
+      exportName: functionExportName(method.function, method.name),
+      symbol: method.function.symbol,
+      ...(method.function.operation ? { operation: method.function.operation } : {}),
+      packageNamespace: method.function.packageNamespace,
+      packageName: method.function.packageName,
+    })),
+    ...schema.fields.flatMap((field) =>
+      field.storage.resolver
+        ? [
+            {
+              exportName: functionExportName(field.storage.resolver, field.name),
+              symbol: field.storage.resolver.symbol,
+              ...(field.storage.resolver.operation
+                ? { operation: field.storage.resolver.operation }
+                : {}),
+              packageNamespace: field.storage.resolver.packageNamespace,
+              packageName: field.storage.resolver.packageName,
+            },
+          ]
+        : [],
+    ),
+    ...operationFunctionSpecs(schema),
+  ];
+  const firstFunction = functionSpecs[0];
+  if (!firstFunction) {
+    throw new Error(`${schema.id.name} has no runtime functions to generate`);
+  }
+  const mixedPackage = functionSpecs.find(
+    (spec) =>
+      spec.packageNamespace !== firstFunction.packageNamespace ||
+      spec.packageName !== firstFunction.packageName,
+  );
+  if (mixedPackage) {
+    throw new Error(
+      `${schema.id.name} points to multiple packages; v0 TS runtime generation expects one package`,
+    );
+  }
+
+  return `${generatedWarning}import {
+  type CaminoClient,
+  createCrdtField,
+  createField,
+  type CrdtField,
+  type Field,
+  type FieldOperation,
+  type InvokeRequest,
+  objectRef,
+  type ObjectRef,
+  type RuntimeHandler,
+  serveQuixosPackageRuntime,
+} from "@quixos/camino-package-runtime";
+
+${interfaceRefTypes ? `${interfaceRefTypes}\n\n` : ""}export type ${refTypeName} = ${refType};
+
+export type ${objectTypeName} = {
+  id: ${refTypeName};
+${writableFields
+  .map(
+    (field) =>
+      `  ${camel(field.name)}: ${tsFieldApiType(field)};`,
+  )
+  .join("\n")}
+};
+
+export type ${contextTypeName} = {
+  object: ${objectTypeName};
+  camino: CaminoClient;
+  request: InvokeRequest;
+};
+
+export type ${implementationTypeName} = {
+${functionSpecs
+  .map((spec) =>
+    spec.operation
+      ? `  ${spec.exportName}: FieldOperation<${contextTypeName}>;`
+      : `  ${spec.exportName}: RuntimeHandler<${contextTypeName}>;`,
+  )
+  .filter((line, index, lines) => lines.indexOf(line) === index)
+  .join("\n")}
+};
+
+const packageNamespace = ${stringLiteral(firstFunction.packageNamespace)};
+const packageName = ${stringLiteral(firstFunction.packageName)};
+const runtimeProtocolVersion = ${stringLiteral("camino-orch-v0")};
+
+const functions = [
+${functionSpecs
+  .map(
+    (spec) =>
+      `  { exportName: ${stringLiteral(spec.exportName)}, symbol: ${stringLiteral(spec.symbol)}${
+        spec.operation ? `, operation: ${stringLiteral(spec.operation)}` : ""
+      }${
+        spec.field
+          ? `, field: { name: ${stringLiteral(spec.field.name)}, type: ${stringLiteral(spec.field.type)}, storage: ${stringLiteral(spec.field.storage)}, conflict: ${stringLiteral(spec.field.conflict)} }`
+          : ""
+      } },`,
+  )
+  .join("\n")}
+] as const;
+
+export const ${createObjectName} = (
+  camino: CaminoClient,
+  objectId: string,
+): ${objectTypeName} => {
+  const id = objectRef<${stringLiteral(classId(schema))}>(objectId) as ${refTypeName};
+  return {
+    id,
+${writableFields
+  .map(
+    (fieldSchema) =>
+      fieldSchema.conflict === "crdt"
+        ? `    ${camel(fieldSchema.name)}: createCrdtField(camino, id, ${stringLiteral(fieldSchema.name)}, ${stringLiteral(crdtStorageTypeId(fieldSchema))}),`
+        : `    ${camel(fieldSchema.name)}: createField(camino, id, ${stringLiteral(fieldSchema.name)}),`,
+  )
+  .join("\n")}
+  };
+};
+
+export const create${className}Context = (
+  camino: CaminoClient,
+  request: InvokeRequest,
+): ${contextTypeName} => ({
+  object: ${createObjectName}(camino, request.objectId),
+  camino,
+  request,
+});
+
+export const ${serveName} = (implementation: ${implementationTypeName}) => {
+  serveQuixosPackageRuntime({
+    packageNamespace,
+    packageName,
+    runtimeProtocolVersion,
+    functions,
+    implementation,
+    createContext: create${className}Context,
+  });
+};
+`;
+};
+
+const renderServer = (schema: ClassSchema, implementationImport: string) => {
+  const className = schema.id.name;
+  return `${generatedWarning}import * as implementation from ${stringLiteral(implementationImport)};
+import { serve${className}Runtime } from "./${schema.id.namespace}.${className}.runtime.js";
+
+serve${className}Runtime(implementation);
+`;
+};
+
+const main = async () => {
+  const sourceFile = required(process.argv[2]);
+  const outDir = required(process.argv[3]);
+  const implementationImport = process.argv[4] ?? "../task.impl.js";
+  const compiled = await compileCaminoSchema(sourceFile);
+  if (compiled.classes.length !== 1) {
+    throw new Error(
+      `Expected exactly one Camino class in ${sourceFile}, found ${compiled.classes.length}`,
+    );
+  }
+  const schema = compiled.classes[0];
+  if (!schema) {
+    throw new Error(`No Camino class found in ${sourceFile}`);
+  }
+  fs.mkdirSync(outDir, { recursive: true });
+  const baseName = `${schema.id.namespace}.${schema.id.name}`;
+  fs.writeFileSync(path.join(outDir, `${baseName}.runtime.ts`), renderRuntime(schema));
+  fs.writeFileSync(
+    path.join(outDir, `${baseName}.server.ts`),
+    renderServer(schema, implementationImport),
+  );
+};
+
+await main();
diff --git a/src/schema-compiler.ts b/src/schema-compiler.ts
new file mode 100644
index 0000000..3b9354a
--- /dev/null
+++ b/src/schema-compiler.ts
@@ -0,0 +1,809 @@
+import fs from "node:fs";
+import path from "node:path";
+import protobuf from "protobufjs";
+import type {
+  Cardinality,
+  ClassSchema,
+  ConflictStrategy,
+  FieldSchema,
+  FieldStorage,
+  FieldStorageKind,
+  FunctionRef,
+  InterfaceFieldContract,
+  InterfaceImplementation,
+  InterfaceSchema,
+  MethodSchema,
+  OperationSchema,
+  OperationServiceSchema,
+  MigrationSpec,
+  SchemaCompileResult,
+  SymbolRef,
+  TypeRef,
+} from "./schema-ir.js";
+
+type OptionBag = Record<string, unknown>;
+
+const CLASS_OPTION = "(camino.class)";
+const INTERFACE_OPTION = "(camino.interface)";
+const IMPLEMENTS_OPTION = "(camino.implements)";
+const CONSTRUCTOR_OPTION = "(camino.constructor)";
+const METHOD_OPTION = "(camino.method)";
+const MIGRATION_OPTION = "(camino.migration)";
+const CONFLICT_OPTION = "(camino.conflict)";
+const EDGE_OPTION = "(camino.edge)";
+const FIELD_STORAGE_OPTION = "(camino.field_storage)";
+const FIELD_OPS_OPTION = "(camino.field_ops)";
+const INTERFACE_FIELD_OPTION = "(camino.interface_field)";
+const DISPLAY_LABEL_OPTION = "(camino.display_label)";
+const IMPL_OPTION = "(camino.impl)";
+const SCHEMA_NAMESPACE_OPTION = "(camino.schema_namespace)";
+const SCHEMA_VERSION_OPTION = "(camino.schema_version)";
+
+const enumName = (value: unknown) =>
+  String(value)
+    .replace(/([a-z0-9])([A-Z])/g, "$1_$2")
+    .replace(/-/g, "_")
+    .toUpperCase();
+
+const lowerEnumName = (value: unknown) => enumName(value).toLowerCase();
+
+const getOption = (
+  options: OptionBag | undefined,
+  name: string,
+): unknown => {
+  if (!options) {
+    return undefined;
+  }
+  if (Object.hasOwn(options, name)) {
+    return options[name];
+  }
+  const bareName = name.replace(/^\((.*)\)$/, "$1");
+  if (Object.hasOwn(options, bareName)) {
+    return options[bareName];
+  }
+  return undefined;
+};
+
+const getParsedOptions = (
+  reflection: protobuf.ReflectionObject,
+): OptionBag[] => {
+  const parsedOptions = (reflection as unknown as { parsedOptions?: unknown })
+    .parsedOptions;
+  return Array.isArray(parsedOptions)
+    ? parsedOptions.filter(
+        (option): option is OptionBag =>
+          Boolean(option) && typeof option === "object" && !Array.isArray(option),
+      )
+    : [];
+};
+
+const getReflectionOptions = (
+  reflection: protobuf.ReflectionObject,
+  name: string,
+): unknown[] => {
+  const parsedValues = getParsedOptions(reflection).flatMap((option) => {
+    const value = getOption(option, name);
+    return value === undefined ? [] : [value];
+  });
+  if (parsedValues.length > 0) {
+    return parsedValues;
+  }
+  const value = getOption(reflection.options, name);
+  return value === undefined ? [] : [value];
+};
+
+const getReflectionOption = (
+  reflection: protobuf.ReflectionObject,
+  name: string,
+): unknown => getReflectionOptions(reflection, name)[0];
+
+const asObject = (value: unknown): OptionBag | undefined =>
+  value && typeof value === "object" && !Array.isArray(value)
+    ? (value as OptionBag)
+    : undefined;
+
+const asArray = (value: unknown): unknown[] =>
+  Array.isArray(value) ? value : value === undefined ? [] : [value];
+
+const readString = (
+  object: OptionBag | undefined,
+  key: string,
+): string | undefined => {
+  const value = object?.[key];
+  return typeof value === "string" ? value : undefined;
+};
+
+const readNumber = (
+  object: OptionBag | undefined,
+  key: string,
+): number | undefined => {
+  const value = object?.[key];
+  return typeof value === "number" && Number.isFinite(value)
+    ? value
+    : undefined;
+};
+
+const readBoolean = (
+  object: OptionBag | undefined,
+  key: string,
+): boolean | undefined => {
+  const value = object?.[key];
+  return typeof value === "boolean" ? value : undefined;
+};
+
+const symbolRefFromOption = (
+  value: unknown,
+  fallback: SymbolRef,
+): SymbolRef => {
+  const object = asObject(value);
+  if (!object) {
+    return fallback;
+  }
+  return {
+    namespace: readString(object, "namespace") ?? fallback.namespace,
+    name: readString(object, "name") ?? fallback.name,
+    version: readString(object, "version") ?? fallback.version,
+    ...(readString(object, "hash")
+      ? { hash: readString(object, "hash") }
+      : {}),
+  };
+};
+
+const typeRefFromOption = (
+  value: unknown,
+  fallbackVersion: string,
+): TypeRef | undefined => {
+  const object = asObject(value);
+  if (!object) {
+    return undefined;
+  }
+  const symbol = asObject(object.symbol)
+    ? symbolRefFromOption(object.symbol, {
+        namespace: "",
+        name: "",
+        version: fallbackVersion,
+      })
+    : undefined;
+  const protoType = readString(object, "proto_type")?.replace(/^\./, "");
+  const symbolProtoType =
+    symbol?.namespace && symbol.name ? `${symbol.namespace}.${symbol.name}` : "";
+  const resolvedProtoType = protoType ?? symbolProtoType;
+  if (!resolvedProtoType) {
+    return undefined;
+  }
+  return {
+    protoType: resolvedProtoType,
+    ...(symbol?.namespace && symbol.name ? { symbol } : {}),
+  };
+};
+
+const interfaceFieldContractFromOption = (
+  value: unknown,
+  schemaVersion: string,
+): InterfaceFieldContract | undefined => {
+  const object = asObject(value);
+  if (!object) {
+    return undefined;
+  }
+  const type = typeRefFromOption(object.type, schemaVersion);
+  return {
+    required: readBoolean(object, "required") ?? false,
+    readable: readBoolean(object, "readable") ?? false,
+    writable: readBoolean(object, "writable") ?? false,
+    watchable: readBoolean(object, "watchable") ?? false,
+    ...(readString(object, "type_param")
+      ? { typeParam: readString(object, "type_param") }
+      : {}),
+    ...(type ? { type } : {}),
+  };
+};
+
+const functionRefFromOption = (value: unknown): FunctionRef => {
+  const object = asObject(value);
+  if (!object) {
+    throw new Error("Expected function ref option object");
+  }
+  const packageNamespace = readString(object, "package_namespace");
+  const packageName = readString(object, "package_name");
+  const symbol = readString(object, "symbol");
+  if (!packageNamespace || !packageName || !symbol) {
+    throw new Error("Function ref requires package_namespace, package_name, and symbol");
+  }
+  return {
+    packageNamespace,
+    packageName,
+    symbol,
+    ...(readString(object, "operation")
+      ? { operation: readString(object, "operation") }
+      : {}),
+    ...(readString(object, "version_ref")
+      ? { versionRef: readString(object, "version_ref") }
+      : {}),
+  };
+};
+
+const conflictFromOption = (value: unknown): ConflictStrategy => {
+  const normalized = enumName(value);
+  if (!value || normalized === "CONFLICT_STRATEGY_UNSPECIFIED") {
+    return "preserve_conflicts";
+  }
+  if (normalized === "REPLACE") {
+    return "replace";
+  }
+  if (normalized === "PRESERVE_CONFLICTS") {
+    return "preserve_conflicts";
+  }
+  if (normalized === "CRDT") {
+    return "crdt";
+  }
+  throw new Error(`Unknown Camino conflict strategy: ${String(value)}`);
+};
+
+const cardinalityFromOption = (value: unknown): Cardinality => {
+  const normalized = lowerEnumName(value);
+  if (!value || normalized === "cardinality_unspecified") {
+    return "many";
+  }
+  if (
+    normalized === "optional_one" ||
+    normalized === "exactly_one" ||
+    normalized === "many" ||
+    normalized === "many_unique" ||
+    normalized === "many_ordered"
+  ) {
+    return normalized;
+  }
+  throw new Error(`Unknown Camino cardinality: ${String(value)}`);
+};
+
+const fieldStorageKindFromOption = (value: unknown): FieldStorageKind => {
+  if (value === 5) {
+    return "static_final";
+  }
+  const normalized = lowerEnumName(value);
+  if (!value || normalized === "field_storage_kind_unspecified") {
+    return "stored";
+  }
+  if (
+    normalized === "stored" ||
+    normalized === "derived" ||
+    normalized === "lazy" ||
+    normalized === "external" ||
+    normalized === "static_final"
+  ) {
+    return normalized;
+  }
+  throw new Error(`Unknown Camino field storage kind: ${String(value)}`);
+};
+
+const fieldStorageFromOption = (value: unknown): FieldStorage => {
+  const object = asObject(value);
+  if (!object) {
+    return {
+      kind: "stored",
+      cache: false,
+    };
+  }
+  const kind = fieldStorageKindFromOption(object.kind);
+  const resolver = object.resolver === undefined
+    ? undefined
+    : functionRefFromOption(object.resolver);
+  if ((kind === "derived" || kind === "lazy" || kind === "external") && !resolver) {
+    throw new Error(`${kind} field storage requires resolver`);
+  }
+  return {
+    kind,
+    ...(resolver ? { resolver } : {}),
+    cache: object.cache === true,
+  };
+};
+
+const fieldOpsFromOption = (value: unknown) => {
+  const object = asObject(value);
+  if (!object) {
+    return undefined;
+  }
+  const implementation = enumName(object.implementation);
+  if (implementation !== "SERVICE") {
+    throw new Error(
+      `Unsupported Camino field implementation: ${String(object.implementation)}`,
+    );
+  }
+  const service = readString(object, "service");
+  if (!service) {
+    throw new Error("SERVICE field_ops requires service");
+  }
+  return {
+    implementation: "service" as const,
+    service,
+  };
+};
+
+const extractFileDefaults = (sourceFile: string) => {
+  const text = fs.readFileSync(sourceFile, "utf8");
+  const packageMatch = /^\s*package\s+([a-zA-Z0-9_.]+)\s*;/m.exec(text);
+  const namespaceMatch =
+    /^\s*option\s+\(camino\.schema_namespace\)\s*=\s*"([^"]+)"\s*;/m.exec(
+      text,
+    );
+  const versionMatch =
+    /^\s*option\s+\(camino\.schema_version\)\s*=\s*"([^"]+)"\s*;/m.exec(text);
+
+  return {
+    packageName: packageMatch?.[1] ?? "",
+    schemaNamespace: namespaceMatch?.[1] ?? packageMatch?.[1] ?? "",
+    schemaVersion: versionMatch?.[1] ?? "1",
+  };
+};
+
+const protoSymbolFromReflection = (
+  reflection: protobuf.ReflectionObject | null,
+  fallbackVersion: string,
+): SymbolRef | undefined => {
+  if (!reflection?.fullName) {
+    return undefined;
+  }
+  const parts = reflection.fullName.replace(/^\./, "").split(".");
+  const name = parts.pop();
+  if (!name) {
+    return undefined;
+  }
+  return {
+    namespace: parts.join("."),
+    name,
+    version: fallbackVersion,
+  };
+};
+
+const typeRefForField = (
+  field: protobuf.Field,
+  schemaVersion: string,
+): TypeRef => {
+  const symbol = protoSymbolFromReflection(field.resolvedType, schemaVersion);
+  const enumValues =
+    field.resolvedType instanceof protobuf.Enum
+      ? Object.entries(field.resolvedType.values)
+          .filter(([_name, value]) => value !== 0)
+          .map(([name]) => name)
+      : undefined;
+  return {
+    protoType: field.type,
+    ...(symbol ? { symbol } : {}),
+    ...(enumValues ? { enumValues } : {}),
+  };
+};
+
+const typeRefForType = (
+  type: protobuf.Type | undefined,
+  fallbackType: string,
+  schemaVersion: string,
+): TypeRef => {
+  const symbol = protoSymbolFromReflection(type ?? null, schemaVersion);
+  return {
+    protoType: type?.fullName?.replace(/^\./, "") ?? fallbackType,
+    ...(symbol ? { symbol } : {}),
+  };
+};
+
+const fieldSchemaFromField = (
+  field: protobuf.Field,
+  schemaVersion: string,
+): FieldSchema => {
+  const storage = fieldStorageFromOption(
+    getReflectionOption(field, FIELD_STORAGE_OPTION),
+  );
+  const ops = fieldOpsFromOption(getReflectionOption(field, FIELD_OPS_OPTION));
+  if (ops && storage.kind !== "stored" && storage.kind !== "static_final") {
+    throw new Error(
+      `Field ${field.fullName} cannot declare both field_ops and package-resolved storage`,
+    );
+  }
+  if (storage.kind === "static_final" && !ops) {
+    throw new Error(`Field ${field.fullName} with static_final storage requires field_ops`);
+  }
+  const interfaceContract = interfaceFieldContractFromOption(
+    getReflectionOption(field, INTERFACE_FIELD_OPTION),
+    schemaVersion,
+  );
+  return {
+    name: field.name,
+    tag: field.id,
+    type: typeRefForField(field, schemaVersion),
+    conflict: conflictFromOption(getReflectionOption(field, CONFLICT_OPTION)),
+    repeated: field.repeated,
+    optional: field.optional,
+    storage,
+    ...(ops ? { ops } : {}),
+    ...(interfaceContract ? { interfaceContract } : {}),
+    isDisplayLabel: getReflectionOption(field, DISPLAY_LABEL_OPTION) === true,
+  };
+};
+
+const isStringType = (type: TypeRef) =>
+  type.protoType === "string" || type.protoType === "google.protobuf.StringValue";
+
+const validateDisplayLabelFields = (
+  type: protobuf.Type,
+  fields: FieldSchema[],
+  operationServices: OperationServiceSchema[],
+) => {
+  const displayLabelFields = fields.filter((field) => field.isDisplayLabel);
+  if (displayLabelFields.length > 1) {
+    throw new Error(
+      `Class ${type.fullName} declares multiple Camino display label fields`,
+    );
+  }
+  const displayLabelField = displayLabelFields[0];
+  if (!displayLabelField) {
+    return;
+  }
+  if (!displayLabelField.ops) {
+    if (!isStringType(displayLabelField.type)) {
+      throw new Error(
+        `Display label field ${type.fullName}.${displayLabelField.name} must have string type`,
+      );
+    }
+    return;
+  }
+  const serviceName = displayLabelField.ops.service.replace(/^\./, "");
+  const getOperation = operationServices
+    .find((service) => service.fullName === serviceName)
+    ?.operations.find((operation) => operation.name === "Get");
+  if (!getOperation || !isStringType(getOperation.outputType)) {
+    throw new Error(
+      `Display label field ${type.fullName}.${displayLabelField.name} must resolve to string`,
+    );
+  }
+};
+
+const typeBindingFromOption = (
+  value: unknown,
+  schemaVersion: string,
+) => {
+  const object = asObject(value);
+  if (!object) {
+    return undefined;
+  }
+  const name = readString(object, "name");
+  const type = typeRefFromOption(object.type, schemaVersion);
+  if (!name || !type) {
+    throw new Error("Interface type_binding requires name and type");
+  }
+  return { name, type };
+};
+
+const interfaceImplementationFromOption = (
+  value: unknown,
+  defaults: ReturnType<typeof extractFileDefaults>,
+): InterfaceImplementation => {
+  const object = asObject(value);
+  if (!object) {
+    throw new Error("Expected implements option object");
+  }
+  const interfaceId = symbolRefFromOption(object.interface, {
+    namespace: defaults.schemaNamespace,
+    name: "",
+    version: defaults.schemaVersion,
+  });
+  if (!interfaceId.name) {
+    throw new Error("implements option requires interface name");
+  }
+  return {
+    interface: interfaceId,
+    typeBindings: asArray(object.type_binding)
+      .map((binding) => typeBindingFromOption(binding, defaults.schemaVersion))
+      .filter((binding): binding is NonNullable<typeof binding> =>
+        Boolean(binding),
+      ),
+  };
+};
+
+const serviceName = (service: protobuf.Service) =>
+  service.fullName.replace(/^\./, "");
+
+const operationFromMethod = (
+  method: protobuf.Method,
+  schemaVersion: string,
+): OperationSchema => {
+  const fn = functionRefFromOption(getReflectionOption(method, IMPL_OPTION));
+  const methodWithTypes = method as protobuf.Method & {
+    resolvedRequestType?: protobuf.Type;
+    resolvedResponseType?: protobuf.Type;
+  };
+  return {
+    name: method.name,
+    inputType: typeRefForType(
+      methodWithTypes.resolvedRequestType,
+      method.requestType,
+      schemaVersion,
+    ),
+    outputType: typeRefForType(
+      methodWithTypes.resolvedResponseType,
+      method.responseType,
+      schemaVersion,
+    ),
+    function: fn,
+  };
+};
+
+const operationServiceFromService = (
+  service: protobuf.Service,
+  schemaVersion: string,
+): OperationServiceSchema => ({
+  name: service.name,
+  fullName: serviceName(service),
+  operations: service.methodsArray.map((method) =>
+    operationFromMethod(method, schemaVersion),
+  ),
+});
+
+const classSchemaFromType = (
+  type: protobuf.Type,
+  sourceFile: string,
+  defaults: ReturnType<typeof extractFileDefaults>,
+  operationServices: OperationServiceSchema[],
+): ClassSchema | undefined => {
+  const classOption = asObject(getReflectionOption(type, CLASS_OPTION));
+  if (!classOption) {
+    return undefined;
+  }
+
+  const fallbackClassRef = {
+    namespace: defaults.schemaNamespace,
+    name: type.name,
+    version: defaults.schemaVersion,
+  };
+  const classId = symbolRefFromOption(classOption.id, fallbackClassRef);
+  const classVersion = readNumber(classOption, "version") ?? Number(classId.version);
+  if (!Number.isInteger(classVersion) || classVersion <= 0) {
+    throw new Error(`Class ${type.fullName} has invalid Camino class version`);
+  }
+
+  const fields = type.fieldsArray.map((field) =>
+    fieldSchemaFromField(field, defaults.schemaVersion),
+  );
+  validateDisplayLabelFields(type, fields, operationServices);
+  const edges = type.fieldsArray.flatMap((field) => {
+    const edgeOption = asObject(getReflectionOption(field, EDGE_OPTION));
+    if (!edgeOption) {
+      return [];
+    }
+    const targetClass = symbolRefFromOption(edgeOption.target, {
+      namespace: defaults.schemaNamespace,
+      name: "",
+      version: defaults.schemaVersion,
+    });
+    if (!targetClass.name) {
+      throw new Error(`Edge field ${type.fullName}.${field.name} requires target`);
+    }
+    const cardinality = cardinalityFromOption(edgeOption.cardinality);
+    const sourceType = typeRefForField(field, defaults.schemaVersion);
+    if (
+      sourceType.symbol?.namespace !== "camino" ||
+      sourceType.symbol.name !== "Ref"
+    ) {
+      throw new Error(`Edge field ${type.fullName}.${field.name} must use camino.Ref`);
+    }
+    const isMany =
+      cardinality === "many" ||
+      cardinality === "many_unique" ||
+      cardinality === "many_ordered";
+    if (isMany && !field.repeated) {
+      throw new Error(`Edge field ${type.fullName}.${field.name} must be repeated for ${cardinality}`);
+    }
+    if (!isMany && field.repeated) {
+      throw new Error(`Edge field ${type.fullName}.${field.name} must not be repeated for ${cardinality}`);
+    }
+    const edgeId = symbolRefFromOption(edgeOption.id, {
+      namespace: defaults.schemaNamespace,
+      name: `${type.name}.${field.name}`,
+      version: defaults.schemaVersion,
+    });
+    return [
+      {
+        id: edgeId,
+        sourceField: field.name,
+        fromClass: classId,
+        toClass: targetClass,
+        cardinality,
+        ...(readString(edgeOption, "inverse")
+          ? { inverse: readString(edgeOption, "inverse") }
+          : {}),
+        fields: [],
+      },
+    ];
+  });
+
+  const methods: MethodSchema[] = getReflectionOptions(type, METHOD_OPTION)
+    .map(asObject)
+    .filter((option): option is OptionBag => Boolean(option))
+    .map((option) => {
+      const name = readString(option, "name");
+      if (!name) {
+        throw new Error(`Method option on ${type.fullName} requires name`);
+      }
+      return {
+        name,
+        function: functionRefFromOption(option.function),
+      };
+    });
+
+  const migrations: MigrationSpec[] = getReflectionOptions(type, MIGRATION_OPTION)
+    .map(asObject)
+    .filter((option): option is OptionBag => Boolean(option))
+    .map((option) => {
+      const fromVersion = readNumber(option, "from_version");
+      const toVersion = readNumber(option, "to_version");
+      if (!fromVersion || !toVersion) {
+        throw new Error(`Migration option on ${type.fullName} requires versions`);
+      }
+      return {
+        fromVersion,
+        toVersion,
+        function: functionRefFromOption(option.function),
+      };
+    });
+
+  const constructorOption = asObject(
+    getReflectionOption(type, CONSTRUCTOR_OPTION),
+  );
+  const constructorSpec = constructorOption
+    ? { function: functionRefFromOption(constructorOption.function) }
+    : undefined;
+
+  return {
+    id: classId,
+    version: classVersion,
+    fields,
+    edges,
+    methods,
+    migrations,
+    operationServices,
+    implements: getReflectionOptions(type, IMPLEMENTS_OPTION).map((option) =>
+      interfaceImplementationFromOption(option, defaults),
+    ),
+    ...(constructorSpec ? { constructorSpec } : {}),
+    sourceFile,
+    protoMessage: type.fullName,
+  };
+};
+
+const interfaceSchemaFromType = (
+  type: protobuf.Type,
+  sourceFile: string,
+  defaults: ReturnType<typeof extractFileDefaults>,
+): InterfaceSchema | undefined => {
+  const interfaceOption = asObject(getReflectionOption(type, INTERFACE_OPTION));
+  if (!interfaceOption) {
+    return undefined;
+  }
+  const classOption = asObject(getReflectionOption(type, CLASS_OPTION));
+  if (classOption) {
+    throw new Error(`${type.fullName} cannot be both a Camino class and interface`);
+  }
+  const fallbackInterfaceRef = {
+    namespace: defaults.schemaNamespace,
+    name: type.name,
+    version: defaults.schemaVersion,
+  };
+  const interfaceId = symbolRefFromOption(
+    interfaceOption.id,
+    fallbackInterfaceRef,
+  );
+  const interfaceVersion =
+    readNumber(interfaceOption, "version") ?? Number(interfaceId.version);
+  if (!Number.isInteger(interfaceVersion) || interfaceVersion <= 0) {
+    throw new Error(`Interface ${type.fullName} has invalid Camino interface version`);
+  }
+  return {
+    id: interfaceId,
+    version: interfaceVersion,
+    fields: type.fieldsArray.map((field) =>
+      fieldSchemaFromField(field, defaults.schemaVersion),
+    ),
+    sourceFile,
+    protoMessage: type.fullName,
+  };
+};
+
+const walkTypes = (
+  namespace: protobuf.NamespaceBase,
+  visit: (type: protobuf.Type) => void,
+) => {
+  for (const nested of namespace.nestedArray) {
+    if (nested instanceof protobuf.Type) {
+      visit(nested);
+      walkTypes(nested, visit);
+    } else if (nested instanceof protobuf.Namespace) {
+      walkTypes(nested, visit);
+    }
+  }
+};
+
+const walkServices = (
+  namespace: protobuf.NamespaceBase,
+  visit: (service: protobuf.Service) => void,
+) => {
+  for (const nested of namespace.nestedArray) {
+    if (nested instanceof protobuf.Service) {
+      visit(nested);
+    } else if (nested instanceof protobuf.Namespace) {
+      walkServices(nested, visit);
+    }
+  }
+};
+
+export const compileCaminoSchema = async (
+  sourceFile: string,
+): Promise<SchemaCompileResult> => {
+  const absoluteSourceFile = path.resolve(sourceFile);
+  const defaults = extractFileDefaults(absoluteSourceFile);
+  const root = new protobuf.Root();
+  const envIncludeDirs = [
+    process.env.QUIXOS_PROTO_PATH,
+    process.env.CAMINO_PROTO_PATH,
+  ]
+    .filter((value): value is string => Boolean(value))
+    .join(path.delimiter)
+    .split(path.delimiter)
+    .map((entry) => entry.trim())
+    .filter(Boolean)
+    .map((entry) => path.resolve(entry));
+  const includeDirs = [
+    path.dirname(absoluteSourceFile),
+    path.resolve("../../quixos-protocol/proto"),
+    path.resolve("quixos-protocol/proto"),
+    path.resolve("proto"),
+    ...envIncludeDirs,
+  ];
+  root.resolvePath = (origin, target) => {
+    if (path.isAbsolute(target) && fs.existsSync(target)) {
+      return target;
+    }
+    const originDir = origin ? path.dirname(origin) : undefined;
+    const candidates = [
+      ...(originDir ? [path.resolve(originDir, target)] : []),
+      ...includeDirs.map((dir) => path.resolve(dir, target)),
+    ];
+    const found = candidates.find((candidate) => fs.existsSync(candidate));
+    return found ?? target;
+  };
+
+  await root.load(absoluteSourceFile, { keepCase: true });
+  root.resolveAll();
+
+  const operationServices: OperationServiceSchema[] = [];
+  walkServices(root, (service) => {
+    operationServices.push(
+      operationServiceFromService(service, defaults.schemaVersion),
+    );
+  });
+
+  const classes: ClassSchema[] = [];
+  const interfaces: InterfaceSchema[] = [];
+  walkTypes(root, (type) => {
+    const interfaceSchema = interfaceSchemaFromType(
+      type,
+      absoluteSourceFile,
+      defaults,
+    );
+    if (interfaceSchema) {
+      interfaces.push(interfaceSchema);
+    }
+    const classSchema = classSchemaFromType(
+      type,
+      absoluteSourceFile,
+      defaults,
+      operationServices,
+    );
+    if (classSchema) {
+      classes.push(classSchema);
+    }
+  });
+
+  return {
+    sourceFile: absoluteSourceFile,
+    classes,
+    interfaces,
+  };
+};
diff --git a/src/schema-ir.ts b/src/schema-ir.ts
new file mode 100644
index 0000000..92fc5b0
--- /dev/null
+++ b/src/schema-ir.ts
@@ -0,0 +1,148 @@
+export type SymbolRef = {
+  namespace: string;
+  name: string;
+  version: string;
+  hash?: string;
+};
+
+export type FunctionRef = {
+  packageNamespace: string;
+  packageName: string;
+  symbol: string;
+  operation?: string;
+  versionRef?: string;
+};
+
+export type ConflictStrategy =
+  | "replace"
+  | "preserve_conflicts"
+  | "crdt";
+
+export type Cardinality =
+  | "optional_one"
+  | "exactly_one"
+  | "many"
+  | "many_unique"
+  | "many_ordered";
+
+export type FieldStorageKind =
+  | "stored"
+  | "derived"
+  | "lazy"
+  | "external"
+  | "static_final";
+
+export type FieldStorage = {
+  kind: FieldStorageKind;
+  resolver?: FunctionRef;
+  cache: boolean;
+};
+
+export type FieldOps = {
+  implementation: "service";
+  service: string;
+};
+
+export type TypeRef = {
+  protoType: string;
+  symbol?: SymbolRef;
+  enumValues?: string[];
+};
+
+export type TypeBinding = {
+  name: string;
+  type: TypeRef;
+};
+
+export type InterfaceFieldContract = {
+  required: boolean;
+  readable: boolean;
+  writable: boolean;
+  watchable: boolean;
+  typeParam?: string;
+  type?: TypeRef;
+};
+
+export type InterfaceImplementation = {
+  interface: SymbolRef;
+  typeBindings: TypeBinding[];
+};
+
+export type FieldSchema = {
+  name: string;
+  tag: number;
+  type: TypeRef;
+  conflict: ConflictStrategy;
+  repeated: boolean;
+  optional: boolean;
+  storage: FieldStorage;
+  ops?: FieldOps;
+  interfaceContract?: InterfaceFieldContract;
+  isDisplayLabel: boolean;
+};
+
+export type EdgeSchema = {
+  id: SymbolRef;
+  sourceField: string;
+  fromClass: SymbolRef;
+  toClass: SymbolRef;
+  cardinality: Cardinality;
+  inverse?: string;
+  fields: FieldSchema[];
+};
+
+export type MethodSchema = {
+  name: string;
+  function: FunctionRef;
+};
+
+export type MigrationSpec = {
+  fromVersion: number;
+  toVersion: number;
+  function: FunctionRef;
+};
+
+export type ConstructorSpec = {
+  function: FunctionRef;
+};
+
+export type OperationSchema = {
+  name: string;
+  inputType: TypeRef;
+  outputType: TypeRef;
+  function: FunctionRef;
+};
+
+export type OperationServiceSchema = {
+  name: string;
+  fullName: string;
+  operations: OperationSchema[];
+};
+
+export type ClassSchema = {
+  id: SymbolRef;
+  version: number;
+  fields: FieldSchema[];
+  edges: EdgeSchema[];
+  methods: MethodSchema[];
+  migrations: MigrationSpec[];
+  operationServices: OperationServiceSchema[];
+  implements: InterfaceImplementation[];
+  constructorSpec?: ConstructorSpec;
+  sourceFile: string;
+  protoMessage: string;
+};
+
+export type InterfaceSchema = {
+  id: SymbolRef;
+  version: number;
+  fields: FieldSchema[];
+  sourceFile: string;
+  protoMessage: string;
+};
+
+export type SchemaCompileResult = {
+  sourceFile: string;
+  classes: ClassSchema[];
+  interfaces: InterfaceSchema[];
+};
diff --git a/yarn-project.nix b/yarn-project.nix
index 8e90bd7..5e99fde 100644
--- a/yarn-project.nix
+++ b/yarn-project.nix
@@ -162,16 +162,29 @@ cacheEntries = {
 "@bufbuild/protoplugin@npm:2.12.1" = { filename = "@bufbuild-protoplugin-npm-2.12.1-e1aebb80bf-c7b401ab31.zip"; hash = "sha512-x7QBqzHZSsaCXLm75c/3XQXSjuINRnskt6XUKZuaygZmhuo5t6OoRTuLWgGD+qd4HoP8LliAZhgHudMVX3Hr6Q=="; };
 "@connectrpc/connect-node@npm:2.1.2" = { filename = "@connectrpc-connect-node-npm-2.1.2-021434d5d5-ba8b0c9384.zip"; hash = "sha512-uosMk4TDgps3eqeoJtwM1Qpgk1J9LscBRgSRKDYzbqlgSitazqQrEEd/i+RWnknd7WbKD8d/X1sCcDXgKeE+qQ=="; };
 "@connectrpc/connect@npm:2.1.2" = { filename = "@connectrpc-connect-npm-2.1.2-ab34825de3-4e15000890.zip"; hash = "sha512-ThUACJAjt1Lv1E+pQKWuHh+gDhvrxLoM7ScruTWSDYw7hbd0UOZErUQruMqaJ1sMFxNviWuo7/A2F4Ex2wHWFQ=="; };
+"@protobufjs/aspromise@npm:1.1.2" = { filename = "@protobufjs-aspromise-npm-1.1.2-71d00b938f-a83343a468.zip"; hash = "sha512-qDNDpGj/W17Gv/Nv14imTIOeSKB/+fT4E1ZPWMr0TQEc1lBO0hR780g1vXp90hBwUq91WWHGsJj9iQK09lANDw=="; };
+"@protobufjs/base64@npm:1.1.2" = { filename = "@protobufjs-base64-npm-1.1.2-cd8ca6814a-eec925e681.zip"; hash = "sha512-7skl5oEIGvGQuO4jH5utMQHhiau8GC/yedprUx59vSpW8fMG83qAsb6eAKotJxaQ0I3MXzJvccnu2FRmdcjK9g=="; };
+"@protobufjs/codegen@npm:2.0.5" = { filename = "@protobufjs-codegen-npm-2.0.5-bb74ff329d-1b8a2ae56e.zip"; hash = "sha512-G4oq5W7mClbp0gXNS2ByoVA8UGm467kFcQ+XT/AJig0HAGQcE34KjZje3xRCMVahBqlDNpXL9SV0gQ9VAA/cqw=="; };
+"@protobufjs/eventemitter@npm:1.1.1" = { filename = "@protobufjs-eventemitter-npm-1.1.1-dbe0dfc812-8e06193d46.zip"; hash = "sha512-jgYZPUYpxefAnU+MLduo/E36c58BSfM6HZAVaNNbt7i1J3pOhFK6873QswL9WZzyVdGTJnqpOgpHR+I80HPErA=="; };
+"@protobufjs/fetch@npm:1.1.1" = { filename = "@protobufjs-fetch-npm-1.1.1-b98d5396a8-a497ff5433.zip"; hash = "sha512-pJf/VDOFToV38EJ5g+o5uRE7SagSD5RRUpHXYzJwYdLDAT5g4k6kNtCR2vrgGg9usYZ+OxYWBF2Wox2LPGRu1A=="; };
+"@protobufjs/float@npm:1.0.2" = { filename = "@protobufjs-float-npm-1.0.2-5678f64d08-18f2bdede7.zip"; hash = "sha512-GPK97edv/PAXBwivFcnJ22JZt3HmuExRsG3zSpwznbvuwmfRTOC93SCswUKx2YDZg9MUNDmN9/mOsMlKDreQaQ=="; };
+"@protobufjs/path@npm:1.1.2" = { filename = "@protobufjs-path-npm-1.1.2-641d08de76-cece0a938e.zip"; hash = "sha512-zs4Kk45/Xf0voD+MFPLxz4sNbhOscyb/TJbqMR7/1ft64LunVPv1BTEq8uOFACUMkOaFBrl8AjYKQ3k9iKDYtA=="; };
+"@protobufjs/pool@npm:1.1.0" = { filename = "@protobufjs-pool-npm-1.1.0-47a76f96a1-eda2718b7f.zip"; hash = "sha512-7aJxi38iKsbmrTb3WKku+Q0mUmAmoZ9PF/Zo9F4DBqW9c03vP0j1H4E0rgl4tiYqXFF8CLEVpVF1bRo6rfzwOA=="; };
+"@protobufjs/utf8@npm:1.1.2" = { filename = "@protobufjs-utf8-npm-1.1.2-9c7ca5968f-975c6e2c03.zip"; hash = "sha512-l1xuLAMZvVDBdTHRhrU3qIy00yBePKkpfNhCtjHTQdoO4/8WvoZWzSZgdW3HU7KcimoUwK2O1gLB+R3fIuez8w=="; };
 "@quixos/camino-datatypes@https://gitea-external.egads.tutti.syntaxblitz.net/quixos/camino-datatypes.git#commit=e061e290709c672d2dc675e5c871733de195211a" = { filename = "@quixos-camino-datatypes-https-faf980267e-4ed01c75c1.zip"; hash = "sha512-TtAcdcG7mReSI/kmbu+U91w39uYetoOiQbq6ex48zaTphDXn1vO1aaw0k8kEDhQgE1LMZrFgHyPzjlUIkyKdrA=="; };
 "@types/node@npm:24.13.3" = { filename = "@types-node-npm-24.13.3-b512a0bbeb-a5bc08f49b.zip"; hash = "sha512-pbwI9JuVgdzcqQ4CzXcZejx5mECAdmSULlzVFhpVPU0q6AZPfjKUQQ10jX0Ji1wYSL5/pQwG8pxBk6sWvk5Z6w=="; };
+"@types/node@npm:26.1.1" = { filename = "@types-node-npm-26.1.1-7a7a9f32f4-25ac509319.zip"; hash = "sha512-JaxQkxlXNt0HTVAnrbuoVhe8lR1aQVBuvTuQcwSKy3IzYT84ItX5uUR/nAhByR9jh8Rig5FnZ+PvefI5F0UsRg=="; };
 "@typescript/vfs@npm:1.6.4" = { filename = "@typescript-vfs-npm-1.6.4-78935c9d3e-acb9de42f2.zip"; hash = "sha512-rLneQvI/2j9149eQC6EG7zI6L0588OSpTbtFfibTU8pjuzUZPtGjL8hzPzrlkJlhKykLBr1iIWlIYb65v7YvYg=="; };
 "debug@npm:4.4.3" = { filename = "debug-npm-4.4.3-0105c6123a-d79136ec6c.zip"; hash = "sha512-15E27GyD7L79D2pVk9pqnJHsTX3cS1TIg9bnHsmsy19noaXpbQCjKBlrW1yG02XpjYo6cIVqrxa057GYXmf1pg=="; };
+"long@npm:5.3.2" = { filename = "long-npm-5.3.2-f80d0f7d39-7130fe1cbc.zip"; hash = "sha512-cTD+HLzi3KBnNLNbcNOAyj9wJxx/iFLJIqfGLIbE418MOSkFZeynEzxiWQjUDhJqxXwCsbGkY2uUV9d+HmC5gQ=="; };
 "ms@npm:2.1.3" = { filename = "ms-npm-2.1.3-81ff3cfac1-d924b57e73.zip"; hash = "sha512-2SS1fnMSs7Y60h/Fs9wK9eeNYaH8fPtUV+2vJjJr9ivlMHzIf/toYu8cKzOwIzzbXU8BxMlYzA1mCUi2Wih6SA=="; };
+"protobufjs@npm:7.6.5" = { filename = "protobufjs-npm-7.6.5-ff4a872120-863eaca9c6.zip"; hash = "sha512-hj6sqcb0W/z7h4fFRfU+nGaWUH4yjjmBtGQ8EtNd9/KCYCHBDj/TC+80LBOo6dMGVHusnAhJ7jv1D3cKEvAdxQ=="; };
 "typescript@npm:5.4.5" = { filename = "typescript-npm-5.4.5-8568a42232-2954022ada.zip"; hash = "sha512-KVQCKto0D9PWqeK45TT2XVfJLV85iaJjdUp4q6VJ9+ZSmswZIZE1YKS4FsRtzn30pNKfnxGj3A1CE7t20EMlHg=="; };
 "typescript@npm:5.9.3" = { filename = "typescript-npm-5.9.3-48715be868-6bd7552ce3.zip"; hash = "sha512-a9dVLOOfl+cR21qgSPb5mVtT8cUvfYZnwavcFwDGinajCPV5zTCc5rU2Rt606aG+fIE6k7qvCijM1TajAnDhxQ=="; };
 "typescript@patch:typescript@npm%3A5.4.5#optional!builtin<compat/typescript>::version=5.4.5&hash=5adc0c" = { filename = "typescript-patch-6e159bfddb-db2ad2a16c.zip"; hash = "sha512-2yrSoWyoKfUEJ+6x2hVeekXlmO7HsIbYtOi6ROWiNfdY5gbWgcZpkiMNP8O4mVhl5f0LIqLJVIbQsyAPgwcuyQ=="; };
 "typescript@patch:typescript@npm%3A5.9.3#optional!builtin<compat/typescript>::version=5.9.3&hash=5786d5" = { filename = "typescript-patch-6fda4d02cf-ad09fdf7a7.zip"; hash = "sha512-rQn996dWgU3OZbxgwWV7QNREUTRoWO6iMOEPLpWiidkYO24y5cEelazAzMIUtPNiidytS/GIawrbhNcR0zakMA=="; };
 "undici-types@npm:7.18.2" = { filename = "undici-types-npm-7.18.2-3e6d69d829-85a7918911.zip"; hash = "sha512-haeRiRE6I4lZ16ZHNo5PfFVZw6QE69uPxEiBRc6UJvzYIlKoRKMCeY38Djfm+xeP9IHtA7xMr2NMV1fZ70NSHQ=="; };
+"undici-types@npm:8.3.0" = { filename = "undici-types-npm-8.3.0-d34470de3e-c8aa7e2fbe.zip"; hash = "sha512-yKp+L76/zlGWVNr63A7OWb6IjSzK8YD7RJXah157U20kVjRcOEBpx+bz6cmrdDXwdJV9owbxQjQ+7ob/gEiFWg=="; };
 };
 
 in overriddenProject
diff --git a/yarn.lock b/yarn.lock
index be65bd7..b47d038 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -66,6 +66,71 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@protobufjs/aspromise@npm:^1.1.1, @protobufjs/aspromise@npm:^1.1.2":
+  version: 1.1.2
+  resolution: "@protobufjs/aspromise@npm:1.1.2"
+  checksum: 10c0/a83343a468ff5b5ec6bff36fd788a64c839e48a07ff9f4f813564f58caf44d011cd6504ed2147bf34835bd7a7dd2107052af755961c6b098fd8902b4f6500d0f
+  languageName: node
+  linkType: hard
+
+"@protobufjs/base64@npm:^1.1.2":
+  version: 1.1.2
+  resolution: "@protobufjs/base64@npm:1.1.2"
+  checksum: 10c0/eec925e681081af190b8ee231f9bad3101e189abbc182ff279da6b531e7dbd2a56f1f306f37a80b1be9e00aa2d271690d08dcc5f326f71c9eed8546675c8caf6
+  languageName: node
+  linkType: hard
+
+"@protobufjs/codegen@npm:^2.0.5":
+  version: 2.0.5
+  resolution: "@protobufjs/codegen@npm:2.0.5"
+  checksum: 10c0/1b8a2ae56ee60a56e9d205cd4b6072a1503c5069b8ebb905710f974ff0098a0d0700641c137e0a8d98dedf14423156a106a9433695cbf52574810f55000fdcab
+  languageName: node
+  linkType: hard
+
+"@protobufjs/eventemitter@npm:^1.1.1":
+  version: 1.1.1
+  resolution: "@protobufjs/eventemitter@npm:1.1.1"
+  checksum: 10c0/8e06193d4629c5e7c09d4f8c2ddba8fc4dfa739f0149f33a1d901568d35bb7b8b5277a4e8452baf3bdd0b302fd599cf255d193267aa93a0a4747e23cd073c4ac
+  languageName: node
+  linkType: hard
+
+"@protobufjs/fetch@npm:^1.1.1":
+  version: 1.1.1
+  resolution: "@protobufjs/fetch@npm:1.1.1"
+  dependencies:
+    "@protobufjs/aspromise": "npm:^1.1.1"
+  checksum: 10c0/a497ff5433854e8577f0427983ea39b9113b49a8120f94515291d763327061d2c3013e60e24ea436d091dafae01a0f6eb1867e3b1616045d96a31d8b3c646ed4
+  languageName: node
+  linkType: hard
+
+"@protobufjs/float@npm:^1.0.2":
+  version: 1.0.2
+  resolution: "@protobufjs/float@npm:1.0.2"
+  checksum: 10c0/18f2bdede76ffcf0170708af15c9c9db6259b771e6b84c51b06df34a9c339dbbeec267d14ce0bddd20acc142b1d980d983d31434398df7f98eb0c94a0eb79069
+  languageName: node
+  linkType: hard
+
+"@protobufjs/path@npm:^1.1.2":
+  version: 1.1.2
+  resolution: "@protobufjs/path@npm:1.1.2"
+  checksum: 10c0/cece0a938e7f5dfd2fa03f8c14f2f1cf8b0d6e13ac7326ff4c96ea311effd5fb7ae0bba754fbf505312af2e38500250c90e68506b97c02360a43793d88a0d8b4
+  languageName: node
+  linkType: hard
+
+"@protobufjs/pool@npm:^1.1.0":
+  version: 1.1.0
+  resolution: "@protobufjs/pool@npm:1.1.0"
+  checksum: 10c0/eda2718b7f222ac6e6ad36f758a92ef90d26526026a19f4f17f668f45e0306a5bd734def3f48f51f8134ae0978b6262a5c517c08b115a551756d1a3aadfcf038
+  languageName: node
+  linkType: hard
+
+"@protobufjs/utf8@npm:^1.1.1":
+  version: 1.1.2
+  resolution: "@protobufjs/utf8@npm:1.1.2"
+  checksum: 10c0/975c6e2c0319bd50c17531d186b537a88cb4d3205e3ca9297cd842b631d341da0ee3ff16be8656cd2660756dc753b29c8a6a14c0ad8ed602c1f91ddf22e7b3f3
+  languageName: node
+  linkType: hard
+
 "@quixos/camino-datatypes@https://gitea-external.egads.tutti.syntaxblitz.net/quixos/camino-datatypes.git#commit=e061e290709c672d2dc675e5c871733de195211a":
   version: 0.1.0
   resolution: "@quixos/camino-datatypes@https://gitea-external.egads.tutti.syntaxblitz.net/quixos/camino-datatypes.git#commit=e061e290709c672d2dc675e5c871733de195211a"
@@ -86,10 +151,22 @@ __metadata:
     "@connectrpc/connect-node": "npm:^2.1.2"
     "@quixos/camino-datatypes": "https://gitea-external.egads.tutti.syntaxblitz.net/quixos/camino-datatypes.git#commit=e061e290709c672d2dc675e5c871733de195211a"
     "@types/node": "npm:^24"
+    protobufjs: "npm:^7.5.4"
     typescript: "npm:^5.9.3"
+  bin:
+    camino-codegen-ts-runtime: dist/src/codegen-ts-runtime.js
   languageName: unknown
   linkType: soft
 
+"@types/node@npm:>=13.7.0":
+  version: 26.1.1
+  resolution: "@types/node@npm:26.1.1"
+  dependencies:
+    undici-types: "npm:~8.3.0"
+  checksum: 10c0/25ac5093195736dd074d5027adbba85617bc951d5a41506ebd3b9073048acb7233613f3822d5f9b9447f9c0841c91f6387c46283916767e3ef79f23917452c46
+  languageName: node
+  linkType: hard
+
 "@types/node@npm:^24":
   version: 24.13.3
   resolution: "@types/node@npm:24.13.3"
@@ -122,6 +199,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"long@npm:^5.3.2":
+  version: 5.3.2
+  resolution: "long@npm:5.3.2"
+  checksum: 10c0/7130fe1cbce2dca06734b35b70d380ca3f70271c7f8852c922a7c62c86c4e35f0c39290565eca7133c625908d40e126ac57c02b1b1a4636b9457d77e1e60b981
+  languageName: node
+  linkType: hard
+
 "ms@npm:^2.1.3":
   version: 2.1.3
   resolution: "ms@npm:2.1.3"
@@ -129,6 +213,25 @@ __metadata:
   languageName: node
   linkType: hard
 
+"protobufjs@npm:^7.5.4":
+  version: 7.6.5
+  resolution: "protobufjs@npm:7.6.5"
+  dependencies:
+    "@protobufjs/aspromise": "npm:^1.1.2"
+    "@protobufjs/base64": "npm:^1.1.2"
+    "@protobufjs/codegen": "npm:^2.0.5"
+    "@protobufjs/eventemitter": "npm:^1.1.1"
+    "@protobufjs/fetch": "npm:^1.1.1"
+    "@protobufjs/float": "npm:^1.0.2"
+    "@protobufjs/path": "npm:^1.1.2"
+    "@protobufjs/pool": "npm:^1.1.0"
+    "@protobufjs/utf8": "npm:^1.1.1"
+    "@types/node": "npm:>=13.7.0"
+    long: "npm:^5.3.2"
+  checksum: 10c0/863eaca9c6f45bfcfb8787c545f53e9c6696507e328e3981b4643c12d35df7f2826021c10e3fd30bef342c13a8e9d306547bac9c0849ee3bf50f770a12f01dc5
+  languageName: node
+  linkType: hard
+
 "typescript@npm:5.4.5":
   version: 5.4.5
   resolution: "typescript@npm:5.4.5"
@@ -175,3 +278,10 @@ __metadata:
   checksum: 10c0/85a79189113a238959d7a647368e4f7c5559c3a404ebdb8fc4488145ce9426fcd82252a844a302798dfc0e37e6fb178ff481ed03bc4caf634c5757d9ef43521d
   languageName: node
   linkType: hard
+
+"undici-types@npm:~8.3.0":
+  version: 8.3.0
+  resolution: "undici-types@npm:8.3.0"
+  checksum: 10c0/c8aa7e2fbebfce519654dafadc0ece59be888d2ccaf180fb4495da875e7b536d2456345c384069c7e6f3e9c9ab7435f074957da306f142343eee86ff8048855a
+  languageName: node
+  linkType: hard