@akterjs/sdk 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,201 @@
+Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -1,3 +1,106 @@
-# Temporary Holding Version
+# @akterjs/sdk
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+The plain TypeScript SDK, for teams that don't write Effect: declare actors with Standard Schema validators, write handlers as plain functions, and call actors through a Promise client that rejects with the declared error classes. It compiles every declaration to `Akter.make` from `@akterjs/effect`, so both SDKs run on the same engine and pass the same engine conformance (ADR 0005, ADR 0015). No Effect type appears in its public surface.
+
+```sh
+npm install @akterjs/sdk
+npm install -D akter
+```
+
+Docs: https://docs.akter.dev. Pricing: https://docs.akter.dev/pricing.
+
+```ts
+import { z } from "zod";
+import { Akter } from "@akterjs/sdk";
+
+export const OverdrawnError = Akter.error("OverdrawnError", z.object({ balance: z.number().int() }));
+
+export const Account = Akter.make("Account", {
+  commands: {
+    deposit: Akter.command({ payload: z.object({ amount: z.number().int() }), success: z.number().int() }),
+    withdraw: Akter.command({ errors: [OverdrawnError], payload: z.object({ amount: z.number().int() }) }),
+  },
+  create: z.object({ owner: z.string() }),
+  key: z.string(),
+  queries: { balance: Akter.query({ success: z.number().int() }) },
+  state: z.object({ balance: z.number().int(), owner: z.string() }),
+});
+
+export const AccountLive = Account.implement({
+  commands: {
+    deposit: (ctx, { amount }) => {
+      ctx.update({ balance: ctx.state.balance + amount });
+
+      return ctx.state.balance + amount;
+    },
+    withdraw: (ctx, { amount }) => {
+      if (amount > ctx.state.balance) {
+        throw new OverdrawnError({ balance: ctx.state.balance - amount });
+      }
+
+      ctx.update({ balance: ctx.state.balance - amount });
+    },
+  },
+  create: (_ctx, { owner }) => ({ balance: 0, owner }),
+  queries: { balance: (ctx) => ctx.state.balance },
+});
+
+export const app = Akter.app([AccountLive]);
+```
+
+## Entry points
+
+| Import                 | What it holds                                                                                                                                                            |
+| ---------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `@akterjs/sdk`         | `Akter.make`, `command`, `query`, `job`, `error`, `app`, the `Principal` and `ActorPrincipal` validators, and the plain types                                            |
+| `@akterjs/sdk/client`  | `createClient({ actors, url, headers })`: `client.Account("acct-1").deposit({ amount: 5 })`, `create`, `ensure`, `warm`, and `subscribe` on queries and state            |
+| `@akterjs/sdk/testing` | `serveLocal({ app })`: the local engine in this process, resolving to `{ url, close, erase }`, for tests and scripts                                                     |
+| `@akterjs/sdk/engine`  | `engineOf(app)`: the Effect actors and layer an app serves, for engines and `@akterjs/conformance`, not for apps. It is the one entry point whose types come from Effect |
+
+`akter dev` and `akter deploy` load `app` from the app module as they do for an Effect app: both read its `actors` and `layer`.
+
+## What a declaration may hold
+
+A validator implements both Standard Schema and Standard JSON Schema, such as Zod 4, ArkType, Valibot through `toStandardJsonSchema`, or Effect Schema through `Schema.toStandardJSONSchemaV1(Schema.toStandardSchemaV1(schema))` (ADR 0015). `Akter.make` exports each declaration's input and output JSON Schema (draft 2020-12) and throws a `PlainDefinitionError`, naming the actor, the member, the part and the reasons, when:
+
+- the validator has no JSON Schema export, or its export throws, as Zod's does for `z.date()`
+- a declaration refers to itself (a recursive `$ref`)
+- a value position accepts anything (`z.unknown()`, `{}`, `true`). `additionalProperties: true` beside declared properties, as Effect Schema exports every struct, is allowed
+- an error class was not made by `Akter.error`, or the actor declares both `initial` and `create`, or neither
+
+At run time, every payload, reply, error, key, principal and state value passes the validator and must come out as JSON, so a validator that returns a `Date` for a string-shaped export fails the call, and the command changes nothing. The captured documents are on `actor.contract`, keyed by member, for history and devtools.
+
+## Handlers
+
+Command, query, create and result handlers are synchronous. They get `ctx` with the actor's `state`, `key`, `principal` and `sql` (a tagged template over the actor's own SQLite database that runs now and returns rows), and a command also gets `update`, `id`, `now`, `send`, `schedule`, `cancel`, `start` and `signal`. A handler that throws a declared error class fails the call with that error and rolls back every write. Anything else it throws, or a Promise it returns, is a defect: I/O belongs in a job (ADR 0007).
+
+A job handler is `async (payload, steps) => value`. `steps.run(name, (step) => ...)` records the step's JSON result (any JSON-safe value, interfaces included; a function, `Date`, `bigint`, symbol or `undefined` field is a type error naming it, such as `NotJson<"a Date">`), and `step.key` is its idempotency key: the same each time this job runs this step, distinct from every other step and job, and `steps.sleep(name, "2 hours")` is a durable timer, so a job that resumes after a restart skips the steps it recorded. `steps.waitFor(name)` waits until a command of the same actor calls `ctx.signal(id, name, value)` with the job's id and resolves to the JSON `value`, recorded like a step, as an approval does. The signal is stored in the command's transaction and wakes the job once it commits, so a command that throws signals nothing and a retried one signals once; a job that has finished or was never started ignores it. Approve another actor's job by sending that actor a command that signals it. A job declared with `patches: ["review-first"]` asks `steps.patched("review-first")`, which is `true` only when the code that started the job declared that patch, so a job in flight keeps its old path across a deploy that changes its steps. The actor's result handler for that job receives `ctx`, the result (`{ outcome: "success", value }`, `{ outcome: "failure", error }` or `{ outcome: "defect", defect }`) and the job, `{ id }`, where `id` is what `ctx.start` returned.
+
+## Parity with the Effect SDK
+
+Built and tested: actors with `initial` or `create`, commands, queries, declared caller kinds, error classes, jobs with recorded steps, durable sleep and signals (`ctx.signal`, `steps.waitFor`), result handlers, `send`, `schedule`, SQL migrations, live queries and state subscriptions, files, computers in jobs, and the captured contract. `@akterjs/conformance` runs every engine guarantee against a plain Ledger with the Effect Ledger's wire contract. Built without a test of their own yet: `cancel` and state upgrades (`state: { from, upgrade }`).
+
+Files: a client uploads bytes with `client.Account(key).files.upload(bytes)` and gets a receipt; a command binds it with `ctx.files.attach(path, receipt)` or drops one with `ctx.files.remove(path)`, both in the command's transaction, so a command that then throws attaches nothing. `ctx.files.list({ prefix?, limit?, cursor? })` and `ctx.files.usage(...)` work in commands, result handlers and queries. Bytes never pass through a handler (ADR 0007): clients read them with `files.download(path, range?)`. A file failure inside a handler, such as an unknown receipt, is thrown as the engine's tagged error (`_tag: "FileNotFoundError"`), and fails the call as a defect unless the handler catches it.
+
+Computers: in a job, `steps.computer(Task, key)` is that actor's computers, the plain face of the Effect `Task.computer(key)`: `ensure`, `get`, `list`, `pause`, `resume`, `stop`, `remove`, `fork` and `exec`, each returning a Promise. Call them inside `steps.run`, and key each exec step with its step's key, as in `steps.run("test", (step) => computers.exec("web", { command: "pnpm test", key: step.key }))`, so a step that runs again reads the recorded outcome back instead of running twice. A failure rejects with the engine's tagged error (`_tag: "ComputerHeldError"`), and a spec or exec request past the limits rejects with `InvalidRequestError` before it reaches a provider. Computers are for jobs only: a command or query does no I/O (ADR 0007). Tested against a recording provider; no engine provides computers until Phase 6 does, so until then every call rejects with `ComputersUnavailableError`.
+
+Fork from the client: `client.Task(key).fork(into)` copies the actor into `into` and resolves with the copy's handle, typed like the original; the copy starts quiet (ADR 0017). It admits only an app's operators, the `user` and `apiKey` kinds. `akter dev` forks. Akter Cloud refuses the fork RPC for every caller by design (`InvalidRequestError`): a fork there is an operator action on the Cloud API (decision 5), made with `akter actors fork`, the `actors_fork` MCP tool or `actorForks.create`. `examples/best-of-n-agent` runs one attempt per fork with it.
+
+Not built yet, each waiting on its engine phase (`../akter-cloud/docs/release-matrix.md` lists their state): fork from a handler or job, branch, snapshot and restore of actors (Phase 7). Each joins `ctx` and the client the way `send` and `start` do here: a method on the erased context in `src/actor/plain-handlers.contract.ts`, typed per actor in `src/actor/plain-types.contract.ts`.
+
+Known limits:
+
+- A handler that catches a step's rejection while its job is being suspended still ends interrupted; the step replays when the job resumes.
+- `serveLocal` runs on the real clock. Drive durable time in tests with `Story` from `@akterjs/effect/testing`, as `tests/actor/plain-actor.contract.test.ts` does.
+
+Local administration: `server.erase({ actor, key })` stops the actor's jobs and removes its computers, file claims and
+database. It is idempotent; a durable marker reserves the erased key in that store and resumes interrupted cleanup
+on restart. It is an explicit in-process method, never an app RPC or a bypass of Cloud's per-target erase approval.
+`serveLocal({ app, computers: true })` opts into local computers for that server; `false` disables them and omitting
+the option keeps `AKTER_LOCAL_COMPUTERS`. These run ordinary local processes, not isolated virtual machines.
+
+## Package
+
+- Depends on: `@akterjs/client` and `@standard-schema/spec` (types only); peers `@akterjs/effect`, `effect` and `@effect/platform-node` (for `serveLocal`). `@akterjs/effect` is a peer so the app, this SDK and the CLI share one copy: `akter dev`, `history` and `migrate` import it from the app's folder to run the actors `Akter.app` compiled, and a second copy would not match them. Install it beside the SDK: `npm install @akterjs/sdk @akterjs/effect effect`.
+- Must not depend on: any private package.
+- `pnpm test` and `pnpm test:bun` run the tests on Node and Bun. `tests/plain-sdk.contract.types.test.ts` compiles a consumer against the built `dist` and fails if its emitted declarations import Effect.

package/dist/actor/json-document.schema.d.mts

@@ -0,0 +1,14 @@
+import { Record, Schema } from "effect";
+import { StandardJSONSchemaV1 } from "@standard-schema/spec";
+type JsonNode = Record.ReadonlyRecord<string, Schema.Json>;
+interface CheckedDocument {
+  readonly document: JsonNode;
+  readonly refusals: readonly string[];
+}
+interface Exporting {
+  readonly converter: StandardJSONSchemaV1.Converter;
+  readonly side: "input" | "output";
+}
+/** Exports one side of a validator's JSON Schema as draft 2020-12 and checks that Akter can store what it describes. */
+declare const exportDocument: ({ converter, side }: Exporting) => CheckedDocument;
+export { type CheckedDocument, type JsonNode, exportDocument };

package/dist/actor/json-document.schema.mjs

@@ -0,0 +1,177 @@
+import { Array, Option, Predicate, Record, Result, Schema, String as String$1, pipe } from "effect";
+// src/actor/json-document.schema.ts
+const definitionPrefix = "#/$defs/";
+const rootReference = "#";
+const annotationKeys = [
+	"$comment",
+	"$id",
+	"$schema",
+	"default",
+	"deprecated",
+	"description",
+	"examples",
+	"readOnly",
+	"title",
+	"writeOnly"
+];
+const dataKeys = [
+	"const",
+	"default",
+	"enum",
+	"examples"
+];
+const schemaListKeys = [
+	"allOf",
+	"anyOf",
+	"oneOf",
+	"prefixItems"
+];
+const schemaKeys = [
+	"additionalProperties",
+	"contains",
+	"else",
+	"if",
+	"items",
+	"not",
+	"propertyNames",
+	"then",
+	"unevaluatedItems",
+	"unevaluatedProperties"
+];
+/** Keys whose `true` opens an object to extra properties beside the declared ones, as Effect Schema exports every struct. The extras are still checked as JSON when stored. */
+const openingKeys = ["additionalProperties", "unevaluatedProperties"];
+/** Whether a keyword's value constrains nothing on purpose: `false` forbids, and `true` on an opening key allows extras. */
+const isDeliberate = (key, value) => value === false || value === true && Array.contains(openingKeys, key);
+const schemaMapKeys = [
+	"dependentSchemas",
+	"patternProperties",
+	"properties"
+];
+const isJsonObject = Schema.is(Schema.JsonObject);
+const isJsonArray = Schema.is(Schema.Array(Schema.Json));
+/** Reads an exporter's document, which a validator library hands back untyped. */
+const jsonObjectOf = Schema.decodeUnknownOption(Schema.JsonObject);
+const objectOf = (node) => Option.liftPredicate(node, isJsonObject);
+const placeOf = (path) => Option.getOrElse(Option.liftPredicate(path, String$1.isNonEmpty), () => "the root");
+const refusal = (path, reason) => `${placeOf(path)} ${reason}`;
+const childPath = (path, key) => Option.match(Option.liftPredicate(path, String$1.isNonEmpty), {
+	onNone: () => key,
+	onSome: (parent) => `${parent}.${key}`
+});
+const definitionName = (reference) => Option.map(Option.liftPredicate(reference, String$1.startsWith(definitionPrefix)), String$1.slice(8));
+/** Finds the definition a `$ref` names, or the reason it cannot be inlined. */
+const expansionOf = (reference, inlining) => {
+	const name = definitionName(reference);
+	if (reference === rootReference || Option.exists(name, (found) => Array.contains(inlining.expanding, found))) return Result.fail(refusal(inlining.path, `refers to itself (${reference}); recursive declarations are not supported`));
+	return Result.fromOption(Option.flatMap(name, (found) => Option.map(Record.get(inlining.definitions, found), (definition) => ({
+		definition,
+		name: found
+	}))), () => refusal(inlining.path, `refers to ${reference}, which the document does not define`));
+};
+const withSiblings = (node, expanded) => Option.match(objectOf(expanded.node), {
+	onNone: () => expanded,
+	onSome: (object) => ({
+		node: {
+			...object,
+			...Record.remove(node, "$ref")
+		},
+		refusals: expanded.refusals
+	})
+});
+const isData = (key) => Array.contains(dataKeys, key) || key === "$defs";
+const joined = (entries) => ({
+	node: Record.fromEntries(Array.map(entries, ([key, inlined]) => [key, inlined.node])),
+	refusals: Array.flatMap(entries, ([, inlined]) => inlined.refusals)
+});
+const referenceOf = (node) => Option.filter(Record.get(node, "$ref"), Predicate.isString);
+const inlineNode = (node, inlining) => {
+	if (isJsonArray(node)) {
+		const items = Array.map(node, (item, index) => inlineNode(item, {
+			...inlining,
+			path: childPath(inlining.path, String(index))
+		}));
+		return {
+			node: Array.map(items, (item) => item.node),
+			refusals: Array.flatMap(items, (item) => item.refusals)
+		};
+	}
+	const inlineObject = (object) => Option.match(referenceOf(object), {
+		onNone: () => joined(Array.map(Record.toEntries(object), ([key, value]) => {
+			if (isData(key)) return [key, {
+				node: value,
+				refusals: []
+			}];
+			return [key, inlineNode(value, {
+				...inlining,
+				path: childPath(inlining.path, key)
+			})];
+		})),
+		onSome: (reference) => Result.match(expansionOf(reference, inlining), {
+			onFailure: (reason) => ({
+				node: object,
+				refusals: [reason]
+			}),
+			onSuccess: ({ definition, name }) => withSiblings(object, inlineNode(definition, {
+				...inlining,
+				expanding: [...inlining.expanding, name]
+			}))
+		})
+	});
+	return Option.match(objectOf(node), {
+		onNone: () => ({
+			node,
+			refusals: []
+		}),
+		onSome: inlineObject
+	});
+};
+const isUnconstrained = (node) => node === true || Option.exists(objectOf(node), (object) => Array.every(Record.keys(object), (key) => Array.contains(annotationKeys, key)));
+const subschemas = (node, path) => [
+	...Array.flatMap(schemaKeys, (key) => pipe(Record.get(node, key), Option.filter((value) => !isDeliberate(key, value)), Option.match({
+		onNone: () => [],
+		onSome: (value) => [[childPath(path, key), value]]
+	}))),
+	...Array.flatMap(schemaListKeys, (key) => pipe(Record.get(node, key), Option.filter(isJsonArray), Option.match({
+		onNone: () => [],
+		onSome: (values) => Array.map(values, (value, index) => [childPath(path, `${key}.${String(index)}`), value])
+	}))),
+	...Array.flatMap(schemaMapKeys, (key) => pipe(Record.get(node, key), Option.flatMap(objectOf), Option.match({
+		onNone: () => [],
+		onSome: (values) => Array.map(Record.toEntries(values), ([name, value]) => [childPath(path, name), value])
+	})))
+];
+const unconstrainedAt = (node, path) => {
+	if (isUnconstrained(node)) return [refusal(path, "accepts any value; declare its shape")];
+	return Option.match(objectOf(node), {
+		onNone: () => [],
+		onSome: (object) => Array.flatMap(subschemas(object, path), ([child, value]) => unconstrainedAt(value, child))
+	});
+};
+const checkObject = (document) => {
+	const definitions = pipe(Record.get(document, "$defs"), Option.flatMap(objectOf), Option.getOrElse(() => ({})));
+	const body = Record.remove(Record.remove(document, "$schema"), "$defs");
+	const inlined = inlineNode(body, {
+		definitions,
+		expanding: [],
+		path: ""
+	});
+	const flat = Option.getOrElse(objectOf(inlined.node), () => ({}));
+	if (Array.isReadonlyArrayEmpty(inlined.refusals)) return {
+		document: flat,
+		refusals: unconstrainedAt(flat, "")
+	};
+	return {
+		document: flat,
+		refusals: inlined.refusals
+	};
+};
+const draft = { target: "draft-2020-12" };
+/** Exports one side of a validator's JSON Schema as draft 2020-12 and checks that Akter can store what it describes. */
+const exportDocument = ({ converter, side }) => Option.match(jsonObjectOf(converter[side](draft)), {
+	onNone: () => ({
+		document: {},
+		refusals: ["the exporter returned a document that is not JSON"]
+	}),
+	onSome: checkObject
+});
+export { exportDocument };

package/dist/actor/plain-actor.contract.d.mts

@@ -0,0 +1,3 @@
+import { PlainAkter } from "./plain-types.contract.mjs";
+/** The plain SDK: define actors with Standard Schema validators and plain functions, served by the same engine as the Effect SDK. */
+export declare const Akter: PlainAkter;

package/dist/actor/plain-actor.contract.mjs

@@ -0,0 +1,63 @@
+import { PlainCompiler } from "./plain-compile.contract.mjs";
+import { PlainErrors } from "./plain-error.schema.mjs";
+import { PlainImplement } from "./plain-implement.contract.mjs";
+import { PlainFileAccesses } from "./resource/plain-file-access.contract.mjs";
+import { actorPrincipal, principal } from "./standard-schema.schema.mjs";
+// src/actor/plain-actor.contract.ts
+function make(name, options) {
+	const compilation = PlainCompiler.compile({
+		name,
+		options
+	});
+	const refs = PlainCompiler.refsOf(() => compilation, {
+		name,
+		options
+	});
+	const implement = (handlers) => {
+		const implementation = { actor: name };
+		PlainImplement.register(implementation, {
+			actor: compilation.compiled.actor,
+			layer: PlainImplement.implement(compilation, handlers)
+		});
+		return implementation;
+	};
+	const actor = {
+		commands: refs.commands,
+		contract: compilation.contract,
+		implement,
+		jobs: refs.jobs,
+		name
+	};
+	PlainCompiler.register(actor, compilation);
+	return actor;
+}
+function command(options = {}) {
+	return {
+		kind: "command",
+		options
+	};
+}
+function query(options = {}) {
+	return {
+		kind: "query",
+		options
+	};
+}
+const job = (options) => ({
+	kind: "job",
+	options
+});
+const app = (declared) => PlainImplement.app(declared);
+/** The plain SDK: define actors with Standard Schema validators and plain functions, served by the same engine as the Effect SDK. */
+const Akter = {
+	ActorPrincipal: actorPrincipal,
+	Principal: principal,
+	app,
+	command,
+	error: PlainErrors.error,
+	fileAccess: PlainFileAccesses.fileAccess,
+	job,
+	make,
+	query
+};
+export { Akter };