@north-light/sdk 0.3.549 → 0.3.551

package/dist/client.d.ts

@@ -1,8 +1,10 @@
-import { type HealthDTO, type MessageResultDTO, type NodeDetailDTO, type ListNodesQuery, type NodeOutcomeDTO, type NodeOutcomeResponseDTO, type NodeSummaryDTO, type ProfileDTO, type ReportDTO, type ReportsQuery, type StatusDTO } from '@north-light/api';
+import { type CheckDTO, type HealthDTO, type MessageResultDTO, type NodeDetailDTO, type ListNodesQuery, type NodeOutcomeDTO, type NodeOutcomeResponseDTO, type NodeSummaryDTO, type ProfileDTO, type ReportDTO, type ReportsQuery, type StatusDTO } from '@north-light/api';
 import { Bash } from './resources/bash.js';
 import { Canvas } from './resources/canvas.js';
 import { Crons } from './resources/crons.js';
 import { Docs } from './resources/docs.js';
+import { Relations } from './resources/relations.js';
+import { Schemas } from './resources/schemas.js';
 import { CustomObjects } from './resources/custom-objects.js';
 import { Attachments } from './resources/attachments.js';
 import { Files } from './resources/files.js';
@@ -130,10 +132,14 @@ export declare class Crouter {
     /** Questions agents in runs ask the user (app listener only). */
     readonly questions: Questions;
     /** Read the documents the person owns (`store: 'user'`): an app sees their `public` documents, `private` ones too while the grant holds
-     *  `crtr:memory:read_private:user` (read-only; `friends` never), and every privacy level with a `crtr:memory:manage:user` grant. */
+     *  `crtr:memory:read_private:user` (read-only), and `crtr:memory:manage:user` covers both. */
     readonly memory: Memory;
     /** Write, read and edit documents the calling app owns (`docs.write`, `docs.edit`, `docs.get`): for example one app-owned `preference` with a `boot` rule that carries the app's agent instructions. */
     readonly docs: Docs;
+    /** Register the app's permission schema (app listener only). */
+    readonly schemas: Schemas;
+    /** Write, replace and list the relation facts of the app's own schema (app listener only). */
+    readonly relations: Relations;
     /** Scope-filtered provider tools and daemon-mediated calls. */
     readonly providers: Providers;
     /** The caller's grant. With `wait` (1–25 s) and `since` (a `version` from an earlier answer), the runtime holds the
@@ -169,6 +175,8 @@ export declare class Crouter {
     private readonly baseURL;
     private readonly socketPath;
     constructor(options?: CrouterOptions);
+    /** May the person `subject` (`user:<id>`) do `permission` on `resource` (`<type>:<id>` in the app's own namespace, or a crouter object id with `read|edit|message|use`)? App listener only. */
+    check(subject: string, permission: string, resource: string, options?: RequestOptions): Promise<CheckDTO>;
     /** Establish NDJSON through the JSON client's cold-socket/retry transport; leave the live body unread. */
     private openCustomDeliveries;
     private openRunEvents;

package/dist/client.js

@@ -4,6 +4,8 @@ import { Bash } from './resources/bash.js';
 import { Canvas } from './resources/canvas.js';
 import { Crons } from './resources/crons.js';
 import { Docs } from './resources/docs.js';
+import { Relations } from './resources/relations.js';
+import { Schemas } from './resources/schemas.js';
 import { CustomObjects } from './resources/custom-objects.js';
 import { Attachments } from './resources/attachments.js';
 import { Files } from './resources/files.js';
@@ -65,10 +67,14 @@ export class Crouter {
     /** Questions agents in runs ask the user (app listener only). */
     questions;
     /** Read the documents the person owns (`store: 'user'`): an app sees their `public` documents, `private` ones too while the grant holds
-     *  `crtr:memory:read_private:user` (read-only; `friends` never), and every privacy level with a `crtr:memory:manage:user` grant. */
+     *  `crtr:memory:read_private:user` (read-only), and `crtr:memory:manage:user` covers both. */
     memory;
     /** Write, read and edit documents the calling app owns (`docs.write`, `docs.edit`, `docs.get`): for example one app-owned `preference` with a `boot` rule that carries the app's agent instructions. */
     docs;
+    /** Register the app's permission schema (app listener only). */
+    schemas;
+    /** Write, replace and list the relation facts of the app's own schema (app listener only). */
+    relations;
     /** Scope-filtered provider tools and daemon-mediated calls. */
     providers;
     /** The caller's grant. With `wait` (1–25 s) and `since` (a `version` from an earlier answer), the runtime holds the
@@ -227,6 +233,8 @@ export class Crouter {
         this.questions = new Questions(request);
         this.memory = new Memory(request);
         this.docs = new Docs(request);
+        this.schemas = new Schemas(request);
+        this.relations = new Relations(request);
         this.runs = new Runs(request, (id, after, signal) => this.openRunEvents(id, after, signal), this.questions);
         this.providers = new Providers(request);
         this.grant = { get: (options = {}) => {
@@ -237,6 +245,10 @@ export class Crouter {
         this.health = { get: (options) => this.request('GET', '/v1/health', undefined, options) };
         this.usage = { get: (params = {}, options) => this.request('GET', withQuery('/v1/usage', { month: params.month }), undefined, options) };
     }
+    /** May the person `subject` (`user:<id>`) do `permission` on `resource` (`<type>:<id>` in the app's own namespace, or a crouter object id with `read|edit|message|use`)? App listener only. */
+    check(subject, permission, resource, options) {
+        return this.request('POST', routes.check(), { subject, permission, resource }, options);
+    }
     /** Establish NDJSON through the JSON client's cold-socket/retry transport; leave the live body unread. */
     async openCustomDeliveries(path, options) {
         const response = await this.call(undefined, () => this.client.rawResponse('GET', path, {

package/dist/index.d.ts

@@ -12,7 +12,9 @@ export type { FileDownloadOptions } from './resources/files.js';
 export type { Upload, UploadCreateParams } from './resources/uploads.js';
 export type { AttachmentLink } from './resources/attachments.js';
 export type { Share, ShareCreated, ShareCreateParams } from './resources/shares.js';
-export type { Doc, DocEditParams, DocWriteParams } from './resources/docs.js';
+export type { Doc, DocEditParams, DocListParams, DocWriteParams } from './resources/docs.js';
+export type { Schemas } from './resources/schemas.js';
+export type { Relations } from './resources/relations.js';
 export type { MemoryDocument, MemoryGetParams, MemoryListItem, MemoryListPage, MemoryListParams } from './resources/memory.js';
 export type { Question, QuestionAnswered, QuestionCanceled, QuestionFields, QuestionKind, QuestionResponses, QuestionSlot, QuestionStatus } from './resources/questions.js';
 export type { ProviderToolEntry } from './resources/providers.js';

package/dist/resources/docs.d.ts

@@ -1,4 +1,4 @@
-import { type DeliveryRuleDTO, type DocEditedDTO, type DocEditRequest, type DocKindName, type DocWriteRequest, type DocWrittenDTO, type ObjectDTO } from '@north-light/api';
+import { type DeliveryRuleDTO, type DocDeletedDTO, type DocEditedDTO, type DocEditRequest, type DocKindName, type DocWriteRequest, type DocWrittenDTO, type ObjectDTO, type ObjectListDTO, type ObjectListRequest, type ObjectSearchDTO, type ObjectSearchRequest } from '@north-light/api';
 import type { RequestOptions } from '../types.js';
 import { type Request } from './request.js';
 /** `docs.write` input. */
@@ -13,9 +13,15 @@ export interface DocWriteParams extends Omit<DocWriteRequest, 'owner' | 'cwd' |
     kind?: DocKindName;
     /** When the document is delivered to a node: `{on: 'boot', deliver: 'content'}` puts the whole body into the context of every node at boot. */
     rules?: DeliveryRuleDTO[];
-    /** Whose document it is. Defaults to the calling app (`'app'`), which is the only owner an app server can write as. */
-    owner?: 'app';
+    /** Whose document it is. Defaults to the calling app (`'app'`). `'user'` writes it under the person the call's token names (`sub`),
+     *  the member the app acts for; the app must hold an active grant from that person. */
+    owner?: 'app' | 'user';
 }
+/** `docs.list` input: the `GET /v1/objects` filters, with `extensions` as an object. */
+export type DocListParams = Omit<ObjectListRequest, 'extensions'> & {
+    /** Documents whose `extensions` hold these top-level fields (equality), e.g. `{ firstlight: { workspace_id: 'w1' } }`. Sent JSON-encoded. */
+    extensions?: ObjectListRequest['extensions'];
+};
 /** `docs.edit` input: a new `body` or exact-text `replace` blocks (not both), and/or document fields. */
 export type DocEditParams = Omit<DocEditRequest, 'base'> & {
     /** The `base` from the `docs.get` the change was computed from. Absent, the edit is made from this app's last `docs.get` or `docs.write` of the document;
@@ -45,6 +51,10 @@ export interface Doc {
     base: string;
     /** The delivery rules the document carries. */
     rules: DeliveryRuleDTO[];
+    /** The plugin-keyed fields the document carries (`{ firstlight: {...} }`); `{}` when none. */
+    extensions: Record<string, Record<string, unknown>>;
+    /** The app type the document is an instance of (`firstlight/memory`); null when it is governed by `crtr/object`. */
+    schema_type: string | null;
 }
 /**
  * Documents the calling app owns (`docs.write` defaults the owner to the app): write one, read it, edit it in place.
@@ -59,6 +69,12 @@ export declare class Docs {
     /** Change a document in place: a new body or replacements, and/or fields (`preview`, `rules`, `privacy`, …). Returns the new `revision`.
      *  `ref` is the canonical name `docs.write` returned. */
     edit(ref: string, params: DocEditParams, options?: RequestOptions): Promise<DocEditedDTO>;
+    /** Delete a document (`ref` is its canonical name or id) and, when it is schema-typed, its facts. Refused like any write the caller may not make. */
+    delete(ref: string, options?: RequestOptions): Promise<DocDeletedDTO>;
+    /** List the objects the app may read, newest first, a page at a time; `extensions` and `schema_type` filter inside the query, before the page limit. */
+    list(params?: DocListParams, options?: RequestOptions): Promise<ObjectListDTO>;
+    /** Search objects by name, `body` text or `grep`; `extensions` and `schema_type` filter inside the query in every mode. */
+    search(params: ObjectSearchRequest, options?: RequestOptions): Promise<ObjectSearchDTO>;
     /** Read a document with its body, revision, edit base and rules. Throws `NotFoundError` when no such document is in the app's view. */
     get(ref: string, options?: RequestOptions): Promise<Doc>;
 }

package/dist/resources/docs.js

@@ -20,6 +20,19 @@ export class Docs {
     edit(ref, params, options) {
         return this.request('PATCH', routes.doc(ref), params, options);
     }
+    /** Delete a document (`ref` is its canonical name or id) and, when it is schema-typed, its facts. Refused like any write the caller may not make. */
+    delete(ref, options) {
+        return this.request('DELETE', routes.doc(ref), undefined, options);
+    }
+    /** List the objects the app may read, newest first, a page at a time; `extensions` and `schema_type` filter inside the query, before the page limit. */
+    list(params = {}, options) {
+        const { extensions, ...rest } = params;
+        return this.request('GET', withQuery(routes.objects(), { ...rest, ...(extensions !== undefined ? { extensions: JSON.stringify(extensions) } : {}) }), undefined, options);
+    }
+    /** Search objects by name, `body` text or `grep`; `extensions` and `schema_type` filter inside the query in every mode. */
+    search(params, options) {
+        return this.request('POST', routes.objectsSearch(), params, options);
+    }
     /** Read a document with its body, revision, edit base and rules. Throws `NotFoundError` when no such document is in the app's view. */
     async get(ref, options) {
         const read = await this.request('GET', withQuery(routes.object(ref), { fields: 1 }), undefined, options);
@@ -42,6 +55,8 @@ export class Docs {
                 ...(match_frontmatter !== undefined ? { match_frontmatter } : {}),
                 ...(condition !== undefined ? { if: condition } : {}),
             })),
+            extensions: data.fields?.extensions ?? {},
+            schema_type: read.object.schema_type ?? null,
         };
     }
 }

package/dist/resources/memory.d.ts

@@ -26,8 +26,8 @@ export interface MemoryListItem {
     kind: 'knowledge' | 'preference';
     preview: string;
     summary: string | null;
-    /** An app sees `public`; `private` too while its grant holds `crtr:memory:read_private:user`; `friends` only with `crtr:memory:manage:user`. */
-    privacy: 'public' | 'friends' | 'private';
+    /** An app sees `public`; `private` too while its grant holds `crtr:memory:read_private:user` (or `crtr:memory:manage:user`). */
+    privacy: 'public' | 'private';
     /** The current revision number. */
     revision: number;
     /** The time of revision 1. */
@@ -55,8 +55,8 @@ export interface MemoryDocument extends MemoryListItem {
 /**
  * Reads the documents the person owns. The daemon filters each one by the caller's
  * grant: an app reads `public` documents with no scope, `private` ones too while the grant
- * holds `crtr:memory:read_private:user` (the person may switch it on and off; `friends` never),
- * and every privacy level with `crtr:memory:manage:user`; a document above the grant's level
+ * holds `crtr:memory:read_private:user` (the person may switch it on and off),
+ * and `manage` covers both; a document above the grant's level
  * reads exactly as an absent one (`NotFoundError`). A run started with a `scopes` list sees
  * `private` only if that list covers `crtr:memory:read_private:user` (names it, or `crtr:memory:manage:user`). Reading records nothing.
  */

package/dist/resources/memory.js

@@ -2,8 +2,8 @@ import { withQuery } from './request.js';
 /**
  * Reads the documents the person owns. The daemon filters each one by the caller's
  * grant: an app reads `public` documents with no scope, `private` ones too while the grant
- * holds `crtr:memory:read_private:user` (the person may switch it on and off; `friends` never),
- * and every privacy level with `crtr:memory:manage:user`; a document above the grant's level
+ * holds `crtr:memory:read_private:user` (the person may switch it on and off),
+ * and `manage` covers both; a document above the grant's level
  * reads exactly as an absent one (`NotFoundError`). A run started with a `scopes` list sees
  * `private` only if that list covers `crtr:memory:read_private:user` (names it, or `crtr:memory:manage:user`). Reading records nothing.
  */

package/dist/resources/relations.d.ts

@@ -0,0 +1,23 @@
+import { type FactDTO, type RelationsChangedDTO, type RelationsListDTO } from '@north-light/api';
+import type { RequestOptions } from '../types.js';
+import { type Request } from './request.js';
+/** The relation facts of the calling app's own schema namespaces (app listener only). A resource is `<type>:<id>`; a subject is `user:<id>`, `<type>:<id>` or `<type>:<id>#<relation>`. */
+export declare class Relations {
+    private readonly request;
+    constructor(request: Request);
+    /** Write and delete facts in one call. Writing a fact that exists, or deleting one that does not, is a no-op. A relation the schema does not declare is refused `400 unknown_relation`; another app's namespace `403 not_schema_owner`. */
+    write(params: {
+        write?: FactDTO[];
+        delete?: FactDTO[];
+    }, options?: RequestOptions): Promise<RelationsChangedDTO>;
+    /** Make the facts `(resource, relation, *)` exactly `subjects`, in one transaction. */
+    replace(params: {
+        resource: string;
+        relation: string;
+        subjects: string[];
+    }, options?: RequestOptions): Promise<RelationsChangedDTO>;
+    /** The facts about one resource. */
+    list(params: {
+        resource: string;
+    }, options?: RequestOptions): Promise<RelationsListDTO>;
+}

package/dist/resources/relations.js

@@ -0,0 +1,21 @@
+import { routes } from '@north-light/api';
+import { withQuery } from './request.js';
+/** The relation facts of the calling app's own schema namespaces (app listener only). A resource is `<type>:<id>`; a subject is `user:<id>`, `<type>:<id>` or `<type>:<id>#<relation>`. */
+export class Relations {
+    request;
+    constructor(request) {
+        this.request = request;
+    }
+    /** Write and delete facts in one call. Writing a fact that exists, or deleting one that does not, is a no-op. A relation the schema does not declare is refused `400 unknown_relation`; another app's namespace `403 not_schema_owner`. */
+    write(params, options) {
+        return this.request('POST', routes.relations(), params, options);
+    }
+    /** Make the facts `(resource, relation, *)` exactly `subjects`, in one transaction. */
+    replace(params, options) {
+        return this.request('PUT', routes.relations(), params, options);
+    }
+    /** The facts about one resource. */
+    list(params, options) {
+        return this.request('GET', withQuery(routes.relations(), params), undefined, options);
+    }
+}

package/dist/resources/schemas.d.ts

@@ -0,0 +1,14 @@
+import { type SchemaRegisterDTO } from '@north-light/api';
+import type { RequestOptions } from '../types.js';
+import type { Request } from './request.js';
+/** The permission schemas an app registers on a person's runtime (app listener only). */
+export declare class Schemas {
+    private readonly request;
+    constructor(request: Request);
+    /** Register or update the calling app's permission schema (SpiceDB syntax) for `namespace`. The first app to register a namespace on a runtime owns it;
+     *  another app naming it is refused `403 namespace_taken`; a source that does not parse is `400 schema_invalid`, and one that drops a relation facts still use is `409 relation_in_use`. `changed` is false when `source` is the registered one. */
+    register(params: {
+        namespace: string;
+        source: string;
+    }, options?: RequestOptions): Promise<SchemaRegisterDTO>;
+}

package/dist/resources/schemas.js

@@ -0,0 +1,13 @@
+import { routes } from '@north-light/api';
+/** The permission schemas an app registers on a person's runtime (app listener only). */
+export class Schemas {
+    request;
+    constructor(request) {
+        this.request = request;
+    }
+    /** Register or update the calling app's permission schema (SpiceDB syntax) for `namespace`. The first app to register a namespace on a runtime owns it;
+     *  another app naming it is refused `403 namespace_taken`; a source that does not parse is `400 schema_invalid`, and one that drops a relation facts still use is `409 relation_in_use`. `changed` is false when `source` is the registered one. */
+    register(params, options) {
+        return this.request('POST', routes.schemas(), params, options);
+    }
+}

package/dist/skill/northlight/SKILL.md

@@ -2,7 +2,7 @@
 name: northlight
 description: "Use when building, debugging or shipping an app that signs people in with Northlight, starts runs on their Northlight runtime, or calls Northlight providers (sms, search, integrations, context, device) with @north-light/sdk."
 metadata:
-  sdk-version: "0.3.549"
+  sdk-version: "0.3.551"
 ---
 
 # Building a Northlight app
@@ -27,7 +27,7 @@ Never text a person first: Comms refuses a send to anyone who has not texted you
 
 ## First: check this skill matches the SDK
 
-This skill is for SDK version `0.3.549`. If the project has `node_modules/@north-light/sdk/package.json`, compare its `version` with that number. If they differ, run `npx @north-light/sdk skill` in the project, then read the rewritten `.agents/skills/northlight/SKILL.md` (or `.claude/skills/northlight/SKILL.md`) instead of this copy. It needs no account. A project that has no SDK yet starts with `npx @north-light/sdk@latest init <dir>`.
+This skill is for SDK version `0.3.551`. If the project has `node_modules/@north-light/sdk/package.json`, compare its `version` with that number. If they differ, run `npx @north-light/sdk skill` in the project, then read the rewritten `.agents/skills/northlight/SKILL.md` (or `.claude/skills/northlight/SKILL.md`) instead of this copy. It needs no account. A project that has no SDK yet starts with `npx @north-light/sdk@latest init <dir>`.
 
 ## Where things run
 

package/dist/testing/cloud.d.ts

@@ -3,10 +3,11 @@ import { Crouter } from '../client.js';
 import { type ConnectionStore } from '../oauth/index.js';
 import { type FakeNotice, type RunNoticeOptions } from './notices.js';
 import { FakeRun } from './run.js';
+import { type SpaceOp } from './space.js';
 import { type FakeRefusalCode, type FakeScope, type FakeUser, type Responder } from './users.js';
 import { type FakeError } from './wire.js';
 /** A runtime operation, named as the daemon's `OPERATIONS` table names it. */
-export type FakeOp = 'grant.get' | 'run.start' | 'run.list' | 'run.get' | 'run.message' | 'run.events' | 'run.interrupt' | 'run.cancel' | 'run.delete' | 'run.rename' | 'question.get' | 'question.answer' | 'question.cancel' | 'trace.get' | 'memory.list' | 'memory.get' | 'provider.tools' | 'provider.call' | 'profile.list';
+export type FakeOp = 'grant.get' | 'run.start' | 'run.list' | 'run.get' | 'run.message' | 'run.events' | 'run.interrupt' | 'run.cancel' | 'run.delete' | 'run.rename' | 'question.get' | 'question.answer' | 'question.cancel' | 'trace.get' | 'memory.list' | 'memory.get' | 'provider.tools' | 'provider.call' | 'profile.list' | SpaceOp;
 /** A directory operation. */
 export type FakeDirectoryOp = 'directory.discovery' | 'directory.token' | 'directory.jwks';
 /** What `intercept` / `failNext` / `gate` match: a runtime operation, `'*'` (every runtime operation), or a directory operation. */
@@ -298,8 +299,8 @@ export declare class FakeCloud {
     private runMessage;
     private question;
     private memoryStore;
-    /** `public` always; `private` with `crtr:memory:read_private:user`; every level with `crtr:memory:manage:user`; `friends` never
-     *  below manage. Unlike the real runtime, which narrows a run to the `scopes` it was started with, this reads the user's whole
+    /** `public` always; `private` with `crtr:memory:read_private:user` or `crtr:memory:manage:user`.
+     *  Unlike the real runtime, which narrows a run to the `scopes` it was started with, this reads the user's whole
      *  grant (`user.grant.set`): narrowed runs are tested on the real runtime. */
     private memoryVisible;
     private memoryList;

package/dist/testing/cloud.js

@@ -10,6 +10,7 @@ import { MemoryConnectionStore, OAuth2Client } from '../oauth/index.js';
 import { SDK_VERSION } from '../version.js';
 import { RunNotices, SigningKey } from './notices.js';
 import { FakeRun } from './run.js';
+import { SPACE_OPS } from './space.js';
 import { UserState, normalizeScopes } from './users.js';
 import { FakeRefused, decodeUnsigned, envelopeBody, fakeError, integerParam, invalid, isFakeError, jsonAnswer, notFound, objectBody, refuse, requestedScopes, sha256Hex, unsignedJwt, waitSeconds, } from './wire.js';
 /** The directory's cap on tester entries per app. */
@@ -35,6 +36,17 @@ const ROUTES = [
     ['GET', /^\/v1\/providers\/([^/]+)\/tools$/, 'provider.tools'],
     ['POST', /^\/v1\/provider\/call$/, 'provider.call'],
     ['GET', /^\/v1\/profiles$/, 'profile.list'],
+    ['POST', /^\/v1\/schemas$/, 'schema.register'],
+    ['POST', /^\/v1\/relations$/, 'relations.write'],
+    ['PUT', /^\/v1\/relations$/, 'relations.replace'],
+    ['GET', /^\/v1\/relations$/, 'relations.list'],
+    ['POST', /^\/v1\/check$/, 'check'],
+    ['POST', /^\/v1\/docs$/, 'doc.write'],
+    ['PATCH', /^\/v1\/docs\/([^/]+)$/, 'doc.edit'],
+    ['DELETE', /^\/v1\/docs\/([^/]+)$/, 'doc.delete'],
+    ['GET', /^\/v1\/objects$/, 'object.list'],
+    ['POST', /^\/v1\/objects\/search$/, 'object.search'],
+    ['GET', /^\/v1\/objects\/([^/]+)$/, 'object.get'],
 ];
 const DIRECTORY_OPS = new Set(['directory.discovery', 'directory.token', 'directory.jwks']);
 const RUN_OPS = new Set(['run.get', 'run.delete', 'run.message', 'run.events', 'run.interrupt', 'run.cancel', 'run.rename', 'trace.get']);
@@ -368,6 +380,7 @@ export class FakeCloud {
             user.runs.length = 0;
             user.responder = null;
             user.memory.clear();
+            user.space.clear();
             user.idempotency.clear();
         }
         this.responder = null;
@@ -596,7 +609,7 @@ export class FakeCloud {
         const id = segment === undefined ? undefined : decodeURIComponent(segment);
         let body = null;
         let badJson = false;
-        if (request.method === 'POST') {
+        if (request.method === 'POST' || request.method === 'PUT' || request.method === 'PATCH') {
             const text = await request.text();
             if (text) {
                 try {
@@ -808,7 +821,10 @@ export class FakeCloud {
             case 'provider.tools': return this.providerTools(user, id);
             case 'provider.call': return this.providerCall(user, body, signal);
             case 'profile.list': return { status: 200, body: { profiles: [{ profile_id: 'default', name: 'default', grantee: this.host.grantee, default_kind: 'general', default: true }] } };
-            default: throw notFound('unknown operation');
+            default:
+                if (SPACE_OPS.has(op))
+                    return user.space.handle(op, id, query, body);
+                throw notFound('unknown operation');
         }
     }
     async grantGet(user, query, signal, claims) {
@@ -976,8 +992,8 @@ export class FakeCloud {
         if (value !== 'user')
             throw invalid('store must be "user"', 'store');
     }
-    /** `public` always; `private` with `crtr:memory:read_private:user`; every level with `crtr:memory:manage:user`; `friends` never
-     *  below manage. Unlike the real runtime, which narrows a run to the `scopes` it was started with, this reads the user's whole
+    /** `public` always; `private` with `crtr:memory:read_private:user` or `crtr:memory:manage:user`.
+     *  Unlike the real runtime, which narrows a run to the `scopes` it was started with, this reads the user's whole
      *  grant (`user.grant.set`): narrowed runs are tested on the real runtime. */
     memoryVisible(user, doc) {
         const scopes = user.scopeStrings();

package/dist/testing/permissions.d.ts

@@ -0,0 +1,37 @@
+import { type Definition } from './schema-parser.js';
+export declare const BUILTIN_SOURCE = "\ndefinition user {}\ndefinition app {}\ndefinition crtr/group {\n  relation member: user | crtr/group#member\n}\ndefinition crtr/object {\n  relation parent: crtr/object\n  relation acts_for: user\n  relation reader: user | user:* | crtr/group#member\n  relation editor: user | crtr/group#member\n  relation messenger: user | crtr/group#member\n  relation user_of: user | crtr/group#member\n  permission read = reader + editor + messenger + user_of + acts_for + parent->read\n  permission edit = editor + acts_for + parent->edit\n  permission message = messenger + acts_for + parent->message\n  permission use = user_of + acts_for + parent->use\n  permission share = acts_for + parent->share\n}\n";
+export declare const OBJECT_TYPE = "crtr/object";
+export type Definitions = ReadonlyMap<string, Definition>;
+export interface FactSubject {
+    type: string;
+    id: string;
+    relation: string;
+}
+export interface Fact {
+    resourceType: string;
+    resourceId: string;
+    relation: string;
+    subject: FactSubject;
+}
+export declare const formatSubject: (s: FactSubject) => string;
+export declare const factKey: (f: Fact) => string;
+/** `<type>:<id>[#<relation>]`; the type may contain `/`. */
+export declare function parseSubject(text: string): FactSubject;
+/** `<type>:<id>` in an app namespace, or a bare crouter object id. */
+export declare function parseResource(text: string): {
+    type: string;
+    id: string;
+};
+export declare const builtinDefinitions: () => Map<string, Definition>;
+/** Parse `source` as the schema of `namespace`: every definition must live in the namespace and every subject type must be declared. */
+export declare function validateSchema(namespace: string, source: string): Definition[];
+/** The relations `previous` declares that `next` drops: `{ name: '<definition>#<relation>' }` for each. */
+export declare function droppedRelations(previous: Definition[], next: Definition[]): Array<{
+    definition: string;
+    relation: string;
+}>;
+/** A fact must name a defined type, a relation that type declares, and a subject the relation lists (so `editor @ user:*` fails like any unlisted subject). */
+export declare function validateFact(defs: Definitions, fact: Fact): void;
+/** Does `userId` hold `permission` on the resource? An unknown type or permission is false, as in the daemon. A person reaches no `crtr/group`:
+ *  an app cannot write group facts, so no group is ever reached here. */
+export declare function holds(defs: Definitions, facts: Iterable<Fact>, userId: string, resourceType: string, resourceId: string, permission: string): boolean;