Implement main-thread Camino sessions and synchronous CRDT editing

src/capability-model/generics.ts

@@ -16,6 +16,7 @@ export type ValueTypeExpression =
   | Extract<ValueType, { kind: "builtin" | "scalar" | "message" }>
   | { kind: "parameter"; parameterId: string }
   | { kind: "record"; fields: Record<string, ValueTypeExpression> }
+  | { kind: "variant"; id: string; cases: Record<string, { id: string; value: ValueTypeExpression }> }
   | { kind: "list" | "optional" | "change"; value: ValueTypeExpression }
   | { kind: "object-ref"; expectation: ObjectTypeExpression }
   | { kind: "alias"; definitionId: string; arguments: TypeArgumentExpression[] };
@@ -195,6 +196,8 @@ export const isStorableType = (
         return false;
       case "record":
         return Object.values(value.fields).every((field) => visit(field, depth + 1));
+      case "variant":
+        return Object.values(value.cases).every((entry) => visit(entry.value, depth + 1));
     }
   };
   return visit(type, 0);
@@ -221,6 +224,14 @@ export const canonicalTypeArgument = (argument: ClosedTypeArgument): string => {
         return [value.kind, value.name];
       case "message":
         return ["message", value.descriptorId];
+      case "variant":
+        return [
+          "variant",
+          value.id,
+          Object.keys(value.cases)
+            .sort()
+            .map((label) => [label, value.cases[label].id, type(value.cases[label].value, depth + 1)]),
+        ];
       case "object-ref":
         return ["object-ref", target(value.expectation)];
       case "change":
@@ -323,6 +334,17 @@ export class TypeSubstitution {
   value(expression: ValueTypeExpression, path = "type", depth = 0): ValueType {
     this.budget.enter(path, depth);
     switch (expression.kind) {
+      case "variant":
+        return {
+          kind: "variant",
+          id: expression.id,
+          cases: Object.fromEntries(
+            Object.entries(expression.cases).map(([label, entry]) => [
+              label,
+              { id: entry.id, value: this.value(entry.value, `${path}.${label}`, depth + 1) },
+            ]),
+          ),
+        };
       case "builtin":
         return { kind: "builtin", name: expression.name };
       case "scalar":