Acquire installed portable operations with explicit authority and input coverage

2026-09-20 02:19:00 -07:00
parent 8fd800e69a
commit d9bd5b2800
18 changed files with 477 additions and 2 deletions
@@ -0,0 +1,57 @@
+import assert from "node:assert/strict";
+import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import {
+  compileCapabilityResourceSource,
+  compileCapabilitySource,
+  formatQx,
+} from "../src/capability-language/index.js";
+import type { InterfaceRevision, PackageRevision } from "../src/capability-model/types.js";
+import { compileQuery } from "../src/query/compile.js";
+import { readReaderFixture } from "./reader-fixture.js";
+const directory = resolve("test/fixtures/local-first-composite");
+export async function loadCompositeWorkspace() {
+  const changed = new Set(["DocumentFactory", "DocumentMetadata", "CommentFactory"]);
+  const read = (name: string) => readFile(resolve(directory, `${name}.qx`), "utf8");
+  const source = { repository: "https://example.test/composite.git", commit: "b".repeat(40) };
+  const interfaces = new Map<string, InterfaceRevision>();
+  for (const name of [
+    "DocumentData",
+    "HighlightData",
+    "CommentData",
+    "DocumentActions",
+    "DocumentFactory",
+    "DocumentMetadata",
+    "CommentFactory",
+  ]) {
+    const result = compileCapabilityResourceSource(
+      formatQx(await (changed.has(name) ? read(name) : readReaderFixture(`${name}.qx`))),
+      { source },
+    );
+    assert.ok(result.ok && result.resource.kind === "interface", JSON.stringify(result.diagnostics));
+    interfaces.set(name, result.resource.revision);
+  }
+  const environment = { interfaces, interfaceClosure: [...interfaces.values()] },
+    packages = new Map<string, PackageRevision>();
+  for (const name of ["ReaderRuntime", "CommentRuntime"]) {
+    const selected =
+      name === "CommentRuntime" ? new Map([["CommentData", interfaces.get("CommentData")!]]) : interfaces;
+    const result = compileCapabilityResourceSource(formatQx(await read(name)), {
+      source,
+      environment: { interfaces: selected, interfaceClosure: [...selected.values()] },
+    });
+    assert.ok(result.ok && result.resource.kind === "package", JSON.stringify(result.diagnostics));
+    const revision = result.resource.revision;
+    revision.checkedQueries = await Promise.all(
+      (revision.queries ?? []).map((query) => compileQuery(query, [...interfaces.values()], readReaderFixture)),
+    );
+    packages.set(name, revision);
+  }
+  const result = compileCapabilitySource(formatQx(await read("workspace")), "workspace.qx", {
+    ...environment,
+    packages,
+    packageClosure: [...packages.values()],
+  });
+  assert.ok(result.ok, JSON.stringify(result.diagnostics));
+  return result.workspace;
+}
@@ -4,6 +4,8 @@ import { loadReaderWorkspace } from "./reader-fixture.js";
 import { compileKernelProgram } from "../src/execution-world/kernel.js";
 import { compileExecutionPlan } from "../src/execution-world/plan.js";
 import { generatePortableTypeScriptBindings } from "../src/bindings/portable.js";
+import { generatePortableClientBindings } from "../src/bindings/portable-client.js";
+import { loadCompositeWorkspace } from "./composite-fixture.js";
 const plan = compileExecutionPlan(await loadReaderWorkspace());
 await mkdir("dist/portable-reader", { recursive: true });
 for (const target of ["browser", "server"])
@@ -13,6 +15,7 @@ for (const target of ["browser", "server"])
  );
 await writeFile("dist/portable-reader/plan.json", JSON.stringify(plan));
 await writeFile("dist/portable-reader/kernel.json", JSON.stringify(compileKernelProgram(plan)));
+await writeFile("dist/portable-reader/client.ts", generatePortableClientBindings(plan, { target: "browser" }));
 const serviceWorkspace = structuredClone(plan.definition.workspace);
 serviceWorkspace.atoms = [];
 serviceWorkspace.conformances = [];
@@ -33,3 +36,16 @@ serviceWorkspace.packageImports[0]!.exports = [
  },
 ];
 await writeFile("dist/portable-reader/service-plan.json", JSON.stringify(compileExecutionPlan(serviceWorkspace)));
+const composite = compileExecutionPlan(await loadCompositeWorkspace());
+await mkdir("dist/portable-reader/composite", { recursive: true });
+await writeFile("dist/portable-reader/composite/plan.json", JSON.stringify(composite));
+await writeFile("dist/portable-reader/composite/kernel.json", JSON.stringify(compileKernelProgram(composite)));
+for (const target of ["browser", "server"])
+  for (const [name, revision] of [
+    ["reader", "package:reader-runtime@1"],
+    ["comment", "package:comment-runtime@1"],
+  ] as const)
+    await writeFile(
+      `dist/portable-reader/composite/${name}-${target}.ts`,
+      generatePortableTypeScriptBindings(composite.definition.bindingSchema, revision, { target }),
+    );
@@ -0,0 +1,7 @@
+external atom Comment id "atom:reader:comment";
+interface CommentFactory id "interface:reader:comment-factory"
+revision "interface:reader:comment-factory@1" {
+  operation prepareComment id "document:prepare-comment" : bool -> atom-ref<Comment> {
+    call id "document:prepare-comment:call" execution transaction targets [browser, server];
+  }
+}
@@ -0,0 +1,11 @@
+external atom Document id "atom:reader:document";
+external atom Comment id "atom:reader:comment";
+import interface CommentData;
+type CommentSeed = record { content: record { text: string; tags: list<string>; }; };
+package CommentRuntime id "package:comment-runtime" revision "package:comment-runtime@1" {
+  operation prepareComment id "comment:prepare"
+  : bool -> atom-ref<Comment> mode call execution transaction targets [browser, server]
+  receiver atom Document requires {
+    creation comment id "comment:prepare:comment" : Comment input CommentSeed;
+  };
+}
@@ -0,0 +1,25 @@
+// Shared record definitions, repeated explicitly in independently locked resources.
+external atom Document id "atom:reader:document";
+external atom Highlight id "atom:reader:highlight";
+external atom Comment id "atom:reader:comment";
+
+type SourceRange = record {
+  sourceRevision: string;
+  start: int32;
+  end: int32;
+};
+
+type CommentContent = record {
+  text: string;
+  tags: list<string>;
+};
+
+type DocumentSeed = record { document: record { sourceRevision: string; content: string; }; metadata: record { label: string; }; };
+
+interface DocumentFactory id "interface:reader:document-factory"
+revision "interface:reader:document-factory@1" {
+  static operation create id "document:create" : DocumentSeed -> atom-ref<Document> {
+    call id "document:create:call"
+    execution transaction targets [browser, server];
+  }
+}
@@ -0,0 +1,6 @@
+interface DocumentMetadata id "interface:reader:document-metadata"
+revision "interface:reader:document-metadata@1" {
+  queryable value label id "document:label" : string {
+    get id "document:label:get" execution snapshot targets [browser, server];
+  }
+}
@@ -0,0 +1,84 @@
+// Shared record definitions, repeated explicitly in independently locked resources.
+external atom Document id "atom:reader:document";
+external atom Highlight id "atom:reader:highlight";
+external atom Comment id "atom:reader:comment";
+
+type SourceRange = record {
+  sourceRevision: string;
+  start: int32;
+  end: int32;
+};
+
+type CommentContent = record {
+  text: string;
+  tags: list<string>;
+};
+
+type DocumentSeed = record { document: record { sourceRevision: string; content: string; }; metadata: record { label: string; }; };
+
+import interface DocumentData;
+import interface CommentFactory;
+import interface HighlightData;
+import interface CommentData;
+type CommentSeed = record { content: CommentContent; };
+type HighlightSeed = record {
+  range: SourceRange;
+  comments: list<record { key: string; target: atom-ref<Comment>; }>;
+};
+
+package ReaderRuntime id "package:reader-runtime"
+revision "package:reader-runtime@1" {
+  operation addHighlight id "reader:add-highlight"
+  : SourceRange -> atom-ref<Highlight>
+  mode call execution transaction targets [browser, server]
+  receiver atom Document requires {
+    interface document id "reader:add:document" : DocumentData
+    using [sourceRevision.get, content.get, highlights.connect];
+    creation highlight id "reader:add:highlight" : Highlight input HighlightSeed;
+    interface comments id "reader:add:comments" : CommentFactory using [prepareComment.call];
+  };
+
+  operation excerpt id "reader:excerpt" : unit -> string
+  mode call execution snapshot targets [browser, server]
+  receiver atom Highlight requires {
+    state range id "reader:excerpt:range" : SourceRange [read];
+    interface document id "reader:excerpt:document" : DocumentData
+    using [sourceRevision.get, content.get];
+  };
+
+  // A receiverless function needs no synthetic service object.
+  function validateRange id "reader:validate-range"
+  : record { range: SourceRange; content: string; } -> bool
+  execution snapshot targets [browser, server];
+
+  function createDocument id "reader:create-document"
+  : DocumentSeed -> atom-ref<Document>
+  execution transaction targets [browser, server] requires {
+    creation document id "reader:create:document" : Document input DocumentSeed;
+  };
+  query ReplicaInputs id "reader:replica-inputs" root DocumentData
+  document "queries/replica-inputs.graphql" operation "ReplicaInputs" {
+    replica;
+    view Highlight as HighlightData;
+    view Comment as CommentData;
+    max rows 5000;
+    max depth 8;
+    max result-bytes 8388608;
+  }
+
+  query ReaderScreen id "reader:screen" root DocumentData
+  document "queries/reader-screen.graphql" operation "ReaderScreen" {
+    local from ReplicaInputs;
+    view Highlight as HighlightData;
+    view Comment as CommentData;
+    max rows 5000;
+    max depth 8;
+    max result-bytes 8388608;
+    watch;
+  }
+
+  query HighlightScope id "reader:highlight-scope" root workspace HighlightData document "queries/highlight-scope.graphql" operation "HighlightScope" { view Comment as CommentData; replica; max rows 200; }
+  query HighlightList id "reader:highlight-list" root workspace HighlightData document "queries/highlight-list.graphql" operation "HighlightList" { view Comment as CommentData; local from HighlightScope; max rows 200; watch; }
+  query HighlightEditorInputs id "reader:editor-inputs" root HighlightData document "queries/editor-inputs.graphql" operation "HighlightEditorInputs" { view Comment as CommentData; replica; max rows 1; }
+  query HighlightEditorView id "reader:editor-view" root HighlightData document "queries/editor-view.graphql" operation "HighlightEditorView" { view Comment as CommentData; local from HighlightEditorInputs; max rows 1; watch; }
+}
@@ -0,0 +1,108 @@
+workspace Reader id "workspace:reader" revision "workspace:reader@1" commit "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" {
+  import interface DocumentData;
+  import interface HighlightData;
+  import interface CommentData;
+  import interface DocumentActions;
+  import interface DocumentFactory;
+  import package ReaderRuntime;
+  import package CommentRuntime;
+  import interface DocumentMetadata;
+  import interface CommentFactory;
+  // Shared record definitions, repeated explicitly in independently locked resources.
+
+  type SourceRange = record {
+    sourceRevision: string;
+    start: int32;
+    end: int32;
+  };
+
+  type CommentContent = record {
+    text: string;
+    tags: list<string>;
+  };
+
+  type DocumentSeed = record { sourceRevision: string; content: string; };
+
+  atom Document id "atom:reader:document";
+  atom Highlight id "atom:reader:highlight";
+  atom Comment id "atom:reader:comment";
+
+  conform Document as DocumentData id "conformance:reader:document-data" {
+    private state Revision id "slot:document:revision"
+    on Document : string policy register;
+    private state Content id "slot:document:content"
+    on Document : string policy register;
+    private edge DocumentHighlights id "edge:document-highlights" {
+      atom Document projection highlights id "projection:highlights" many-unique;
+      atom Highlight projection document id "projection:document"
+      exactly-one public-traversal;
+    }
+    initialize {
+      sourceRevision to state Revision;
+      content to state Content;
+    };
+    bind sourceRevision.get to state Revision.read;
+    bind content.get to state Content.read;
+    bind highlights.resolve to edge DocumentHighlights.highlights.resolve;
+    bind highlights.connect to edge DocumentHighlights.highlights.connect;
+  }
+
+  conform Document as DocumentActions id "conformance:reader:document-actions" {
+
+    bind annotate.call to package ReaderRuntime.addHighlight with {
+      document to interface DocumentData;
+      highlight to creation Highlight with { HighlightData from input; };
+      comments to interface CommentFactory;
+    };
+  }
+
+  conform Document as CommentFactory id "conformance:reader:comment-factory" {
+    bind prepareComment.call to package CommentRuntime.prepareComment with {
+      comment to creation Comment with { CommentData from input; };
+    };
+  }
+
+  conform Document as DocumentMetadata id "conformance:reader:document-metadata" {
+    private state Label id "slot:document:label" on Document : string policy register;
+    initialize { label to state Label; };
+    bind label.get to state Label.read;
+  }
+
+  conform Document as DocumentFactory id "conformance:reader:document-factory" {
+    bind create.call to package ReaderRuntime.createDocument with {
+      document to creation Document with { DocumentData from input.document; DocumentMetadata from input.metadata; };
+    };
+  }
+
+  conform Highlight as HighlightData id "conformance:reader:highlight-data" {
+    private state Range id "slot:highlight:range"
+    on Highlight : SourceRange policy register;
+    private state Color id "slot:highlight:color"
+    on Highlight : string policy register default "yellow";
+    private edge HighlightComments id "edge:highlight-comments" {
+      atom Highlight projection comments id "projection:comments" many-unique;
+      atom Comment projection highlight id "projection:highlight"
+      exactly-one public-traversal;
+    }
+    initialize {
+      range to state Range;
+      comments to edge HighlightComments.comments;
+    };
+    bind range.get to state Range.read;
+    bind color.get to state Color.read;
+    bind color.set to state Color.write;
+    bind comments.resolve to edge HighlightComments.comments.resolve;
+    bind excerpt.get to package ReaderRuntime.excerpt with {
+      range to state Range;
+      document to interface DocumentData via edge DocumentHighlights.document;
+    };
+  }
+
+  conform Comment as CommentData id "conformance:reader:comment-data" {
+    private state CommentBody id "slot:comment:content"
+    on Comment : CommentContent policy crdt(CommentContent);
+    initialize { content to state CommentBody; };
+    bind content.get to state CommentBody.read;
+    bind content.edit to state CommentBody.edit;
+  }
+}
@@ -0,0 +1,29 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { loadReaderWorkspace } from "./reader-fixture.js";
+import { compileExecutionPlan, checkResultProjection, publicOperationKey } from "../src/execution-world/index.js";
+test("factory result observation checks direct replica roots against the result contract", async () => {
+  const plan = compileExecutionPlan(await loadReaderWorkspace());
+  const query = (id: string) => JSON.stringify(["package:reader-runtime@1", id]);
+  const create = publicOperationKey(
+    "atom:reader:document",
+    "interface:reader:document-factory@1",
+    "document:create:call",
+  );
+  const annotate = publicOperationKey(
+    "atom:reader:document",
+    "interface:reader:document-actions@1",
+    "document:annotate:call",
+  );
+  assert.equal(checkResultProjection(plan, create, query("reader:replica-inputs")).id, query("reader:replica-inputs"));
+  assert.equal(checkResultProjection(plan, annotate, query("reader:editor-inputs")).id, query("reader:editor-inputs"));
+  assert.throws(() => checkResultProjection(plan, create, query("reader:editor-inputs")), {
+    code: "RESULT_PROJECTION_MISMATCH",
+  });
+  assert.throws(() => checkResultProjection(plan, annotate, query("reader:highlight-scope")), {
+    code: "INVALID_RESULT_PROJECTION",
+  });
+  assert.throws(() => checkResultProjection(plan, annotate, query("reader:editor-view")), {
+    code: "INVALID_RESULT_PROJECTION",
+  });
+});