nervur 0.23.0 → 0.24.0

package/WORLD.md

@@ -1,195 +0,0 @@
-# Reading a world
-
-nervur has four pieces: grounds, faculties, houses and beings. They can
-model any situation, so they give no order by themselves. This guide
-gives the order. It takes a real situation, with its people,
-organisations, machines, apps and sensors, and reads it into those four
-pieces. It adds nothing to the library. [Writing for
-nervur](AUTHORING.md) teaches beings and grounds, and [Writing a
-faculty](FACULTIES.md) teaches faculties.
-
-## Three questions
-
-Ask three questions of every real thing, and choose its terrain last.
-
-1. **Whose will does it serve?** A will is one owner, a person or an
-   organisation. Inside one will the owner possesses everything. The
-   design work is at the borders, where a relation crosses from one will
-   to another.
-2. **Is it a mind, a thing or a matter?** A mind decides: a human, an AI
-   agent, an organisation acting through its systems. A thing senses or
-   acts and decides nothing: a camera, a sensor, a shell, a payment API.
-   A matter is work several parties share: an order, a booking, a case.
-3. **Can it be asked?** The end of a relation that others ask must stand
-   on a ground they can reach. So reach decides where a being lives.
-
-## Two kinds of being
-
-**Every being is a twin or a matter.** A twin maps one thing outside the
-house into it, through one entry. A matter lives inside the house alone,
-and shares work between twins.
-
-| Twin of | Enters by | Being |
-| --- | --- | --- |
-| the house's owner | the hand | the steward |
-| any stranger | a face with no token, or Quo with no relation | the public being |
-| one known will | a face with a token, or Quo | a representative |
-| one thing | a faculty | the twin of that thing |
-
-**The steward is the twin of the house's owner.** The owner is whoever
-holds the house's seed.
-
-**A representative is the twin of one known will.** That will may be a
-human on a site, a human with an AI agent over MCP, an organisation's
-script over an API, or another house over Quo. Her occupants are that
-will's doors in. Her standings are its accounts out.
-
-**A representative in a shop and an avatar at home are one shape.** At a
-shop, Alice's representative holds what the shop's class lets her hold.
-In Alice's own house, her avatar is the same shape, and Alice's class
-decides.
-
-**The twin of a thing is the one being granted its faculty.** The
-faculty is the process or service that touches the thing. The ground
-grants it to the twin's kind alone. The twin holds the thing's policy,
-state and history.
-
-**A matter is shared work.** An order between a customer and a shop, a
-case between a lawyer and a court, and a family calendar are matters.
-Each is reached only through the representatives and twins of those who
-share it.
-
-## The rules between them
-
-- A mind reaches a matter only through its representative.
-- A matter or a representative reaches a thing only through its twin.
-- A faculty never crosses from one will to another. The other will
-  holds a standing on the twin, and the twin applies its policy.
-- Nothing outside the house touches a matter directly.
-- The border of a house is its twins, one for each outside thing. Its
-  inside is its matters.
-
-## How a human enters
-
-**A human enters in one of two ways.**
-
-- **Possessing.** She sits at the machine and asks through the hand,
-  with the `nervur` command or an app's own screens. She is `root` on
-  every house of that ground.
-- **Living.** She enters through a face, a site, an API or an MCP
-  server, with a token. She is one occupant of one being, and reaches
-  only what that being's table allows her.
-
-**Quo is not a human's entry.** Quo carries asks between houses. When
-Alice's home asks a shop, her avatar asks for her.
-
-**The hand never leaves its machine.** A human away from the machine
-lives through a face, even in her own house.
-
-## A person, seen from two sides
-
-**A shop sees a person as one being with many doors.** Each occupant of
-her representative is one way she reaches it: a browser's token, one of
-her devices, or her home. The shop never needs to know that the doors
-are one person.
-
-**One reachable house becomes a person's home.** It holds her standings
-on every shop, and each of her devices holds a standing on it. A shop
-then sees one door from her, and a lost device is revoked at home,
-touching no shop.
-
-## Stations and devices
-
-**Every ground is a station or a device, by whether it can be asked.**
-
-- **A station can be asked.** Representatives, the public being and
-  shared matters live there.
-- **A device cannot be asked.** The twins of physical things live there,
-  beside their things. Each device holds a standing on one station.
-
-| Ground | Family | What lives on it |
-| --- | --- | --- |
-| NodeGround | a station on a server; a device on a desktop or a Pi behind a router | anything its reach allows |
-| EdgeGround | a station with no machine | the public being, representatives, shared matters |
-| AppGround | a device, woken by launch and by push | the steward, twins of the phone's things |
-| BrowserGround | a device bound to its origin | the steward, twins of the browser's things |
-| BenchGround | every family, in memory | a whole world under test |
-
-**Representatives live on stations alone.** Others must ask them, so
-they need a ground that can be reached.
-
-**The twin of a physical thing lives beside it.** A camera's twin stands
-on the Pi or the phone that touches the camera.
-
-**A device keeps matters only for its own autonomy.** A thermostat rule
-between a temperature twin and a heater twin runs on the Pi while the
-network is down. Every matter another will shares lives on a station.
-
-**A device cannot be asked, so it asks.** Its twins send readings up as
-effects to a mirror on its station, and it watches the mirror for what
-waits for it. Every other will holds a standing on the mirror, and never
-on the device.
-
-## Four roles
-
-**Crossing the owner with the family gives four roles.**
-
-| | Station | Device |
-| --- | --- | --- |
-| A person's | home | device |
-| An organisation's | shop | outpost |
-
-## A garage, read whole
-
-**The garage door is a thing, and its relay is a faculty on a Pi.** One
-pulse toggles the door, so a pulse sent twice opens it and closes it
-again. The relay's program keeps each call id before it pulses.
-
-**The door's twin is the one being granted the relay.** She keeps who
-opened the door and which pulse did it. The Pi is an outpost of the
-family: it only dials, and opens no port.
-
-**The door's mirror stands on the family's station, and the twin watches
-it.** An opening lands on the mirror and reaches the Pi at once, over one
-held line.
-
-**Alice's phone asks the mirror.** Each tap pulses once, across a crash
-of the program and a lost reply, since each hop carries one call id. Bob
-and a babysitter hold standings on the mirror too, and never reach the
-Pi.
-
-## Minds that are not human
-
-**An AI agent is a mind.** One working for a person gets a
-representative and lives through an MCP face, or runs from a house of
-its own and asks over Quo. It is never a faculty.
-
-**A model called for a completion is a thing.** A being that asks a
-model to help her decide calls a faculty through her twin of it. The
-being decides, and the model answers.
-
-**A script that speaks no Quo is a mind or a thing.** A script that acts
-as a client lives through an API face with a token. A program the house
-calls is a thing, wrapped as a faculty by the bridge.
-
-## The order, step by step
-
-1. Draw the wills.
-2. In each will, list its minds, its things and its matters.
-3. Give each mind a representative, each thing a twin, and each matter a
-   being.
-4. Place each twin of a physical thing at its thing, and every
-   representative and matter on a station of the will that owns it.
-5. Connect wills only through representatives and twins.
-6. Check that every end others ask stands on a station, and make each
-   device push up and pull down.
-7. Choose the terrain of each ground last.
-
-## What the reading refuses
-
-- A fifth piece. A twin, a matter, a station and a device are readings
-  of the four.
-- A faculty granted across a will.
-- A representative on a device, where no one can ask her.
-- A matter shared with another will on a device.
-- A human entering by any way but the hand or a face.

package/dist/app/app-ground.d.ts

@@ -1,18 +0,0 @@
-import { type BrowserGround, type BrowserGroundOptions } from '../browser/browser-ground.ts';
-import { type NativeSecrets, type NativeStore } from './native.ts';
-/** What the shell hands the ground: its secret store and its native store. */
-export interface NativeShell {
-    readonly secrets: NativeSecrets;
-    readonly store: NativeStore;
-}
-export interface AppGroundOptions extends Omit<BrowserGroundOptions, 'platform'> {
-    readonly shell: NativeShell;
-    /** Loads a module of classes by URL, where the app's build hands its own. */
-    readonly load?: (href: string) => Promise<unknown>;
-    /** Where its classes stand; the web view's own origin where omitted. */
-    readonly origin?: string;
-}
-export declare const AppGround: Readonly<{
-    /** The app's ground: a BrowserGround whose unlock and memory are the shell's own. */
-    open({ shell, load, origin, ...options }: AppGroundOptions): Promise<BrowserGround>;
-}>;

package/dist/app/app-ground.js

@@ -1,23 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// The ground in a phone's app: a BrowserGround in the shell's web view,
-// on the two bodies the shell hands in. Its key rests in the platform's
-// Keychain or Keystore, and its memory in a native store the system never
-// evicts. The code arrives signed in the app's bundle, and one web view
-// runs, so the lock is taken at once. A wake by push is the app's own
-// registry's faculty, since the library ships no faculty.
-import { openOn } from '../browser/browser-ground.js';
-import { NativeMemory, NativeUnlock } from './native.js';
-export const AppGround = Object.freeze({
-    /** The app's ground: a BrowserGround whose unlock and memory are the shell's own. */
-    open({ shell, load, origin, ...options }) {
-        return openOn({
-            ...options,
-            platform: {
-                // The system keeps an app's own store, so there is nothing to ask.
-                persist: async () => true,
-                ...(load === undefined ? {} : { load }),
-                ...(origin === undefined ? {} : { origin }),
-            },
-        }, { unlock: async () => new NativeUnlock(shell.secrets), memory: async (name) => new NativeMemory(shell.store, name) });
-    },
-});

package/dist/app/index.d.ts

@@ -1,2 +0,0 @@
-export { AppGround, type NativeShell } from './app-ground.ts';
-export { NativeMemory, NativeUnlock, type NativeSecrets, type NativeStore } from './native.ts';

package/dist/app/index.js

@@ -1,5 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// `nervur/app`: the ground of a phone's app, a BrowserGround on the bodies
-// its shell hands in, and the contracts a shell's native code fills.
-export { AppGround } from './app-ground.js';
-export { NativeMemory, NativeUnlock } from './native.js';

package/dist/app/native.d.ts

@@ -1,11 +0,0 @@
-import { KeptMemory, KeptUnlock, type Secrets, type Store } from '../bodies/kept.ts';
-/** The platform's secret store: text by name, kept by the Keychain or the Keystore, on this device alone. */
-export type NativeSecrets = Secrets;
-/** A native store of text by key, which the operating system never evicts, with a swap that lands only where nothing moved. */
-export type NativeStore = Store;
-/** The ground's key in the platform's secret store, drawn on first use. The store is the protection, on this device alone. */
-export declare class NativeUnlock extends KeptUnlock {
-}
-/** Memory in the native store, one for each name, which the system never evicts. */
-export declare class NativeMemory extends KeptMemory {
-}

package/dist/app/native.js

@@ -1,13 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// The two native bodies of a phone's ground, over what the shell hands in.
-// The shell's secret store is the iOS Keychain or the Android Keystore, and
-// its store is a native file or database the operating system never
-// evicts. The library holds the contracts' logic; a shell holds only the
-// two small interfaces below, in its own native code.
-import { KeptMemory, KeptUnlock } from '../bodies/kept.js';
-/** The ground's key in the platform's secret store, drawn on first use. The store is the protection, on this device alone. */
-export class NativeUnlock extends KeptUnlock {
-}
-/** Memory in the native store, one for each name, which the system never evicts. */
-export class NativeMemory extends KeptMemory {
-}

package/dist/being/being.d.ts

@@ -1,306 +0,0 @@
-import type { MethodSpec, Need, BLUEPRINT } from './need.ts';
-import type { Handle, Inbound, Infer, Invitation, Outbound } from './schema.ts';
-/** A JSON value, as cells and notes hold. */
-export type Json = null | boolean | number | string | readonly Json[] | {
-    readonly [key: string]: Json;
-};
-/** What a call outward carries: JSON, bytes, and the handles and invitations the callee's schema places. */
-export type Passed = Json | Uint8Array | Handle | Invitation | readonly Passed[] | {
-    readonly [key: string]: Passed;
-};
-/** Notes on a relation. */
-export type Notes = Readonly<Record<string, Json>>;
-/** Where the house placed her. */
-export type Position = 'steward' | 'public' | 'normal';
-/** Who asks now. */
-export interface Asker {
-    readonly id: string;
-    readonly notes: Notes;
-    readonly steward: Notes;
-    readonly signer?: Uint8Array;
-}
-/** What a role and her state read of her. */
-export interface Me<C> {
-    readonly id: string;
-    readonly position: Position;
-    readonly cells: Readonly<C>;
-}
-type Names = string | readonly string[];
-/**
- * One example of an ask, run by the bench and nowhere else. `given` is the
- * history of her own asks that brings her from her `born` to where the
- * example starts.
- */
-export interface Example {
-    readonly description?: string;
-    readonly given?: readonly {
-        readonly ask: string;
-        readonly args?: Json;
-        readonly role?: string;
-    }[];
-    readonly role?: string;
-    readonly args?: Json;
-    readonly fakes?: Json;
-    readonly gives?: Json;
-}
-/** An ask's entry: the method's gate. */
-export interface Entry extends MethodSpec {
-    readonly in?: Names;
-    readonly for?: Names;
-    readonly to?: Names;
-    readonly examples?: readonly Example[];
-}
-/** What a class declares. */
-export interface Declaration<C = Record<string, Json>, N = Record<string, Need>, A = Record<string, Entry>> {
-    readonly kind: string;
-    readonly description?: string;
-    readonly cells?: C;
-    readonly needs?: N;
-    readonly roles?: Readonly<Record<string, (asker: Asker, me: Me<C>) => boolean>>;
-    readonly state?: (me: Me<C>) => string;
-    readonly asks: A;
-    /** Markup as text over her asks, which a screen renders. */
-    readonly view?: string;
-}
-/** A relation, with her notes and her steward's. */
-export interface Relation {
-    readonly id: string;
-    readonly notes: Notes;
-    readonly steward: Notes;
-}
-type Resolved<S> = S extends {
-    readonly result: infer R;
-} ? Inbound<Infer<R>> : null;
-type Sent<S> = S extends {
-    readonly args: infer A;
-} ? Outbound<Infer<A>> : Record<string, never>;
-type IsAwaited<S> = S extends {
-    readonly hints: {
-        readonly idempotent: true;
-    };
-} ? true : S extends {
-    readonly hints: {
-        readonly readOnly: true;
-    };
-} ? true : false;
-/** How she calls one method: awaited, or an effect answered through `reply`. */
-type Given<S, O extends unknown[]> = {} extends Sent<S> ? [args?: Sent<S>, ...O] : [args: Sent<S>, ...O];
-type IsReadOnly<S> = S extends {
-    readonly hints: {
-        readonly readOnly: true;
-    };
-} ? true : false;
-export type Call<S, R extends string> = IsReadOnly<S> extends true ? ((...given: Given<S, [options: {
-    after: Resolved<S>;
-    reply: R;
-}]>) => void) & ((...given: Given<S, [options?: {
-    after?: Resolved<S>;
-}]>) => Promise<Resolved<S>>) : IsAwaited<S> extends true ? (...given: Given<S, []>) => Promise<Resolved<S>> : (...given: Given<S, [options?: {
-    reply?: R;
-}]>) => void;
-/** The frozen face of a need: its methods and nothing else. */
-export type Face<X, R extends string = string> = {
-    readonly [K in Exclude<keyof X, typeof BLUEPRINT>]: Call<X[K], R>;
-};
-/** A standing asked with no need matched, such as her steward. */
-export type Untyped = Readonly<Record<string, (args?: Passed, options?: {
-    reply?: string;
-}) => Promise<unknown> | void>>;
-/** One ask as a far being's describe shows it: its schemas, its hints and its wait. */
-export interface Described {
-    readonly method: string;
-    readonly description?: string;
-    readonly in?: readonly string[];
-    readonly to?: readonly string[];
-    readonly args?: Json;
-    readonly result?: Json;
-    readonly hints?: {
-        readonly readOnly?: boolean;
-        readonly idempotent?: boolean;
-        readonly destructive?: boolean;
-    };
-    readonly wait?: number;
-}
-/**
- * A standing asked with no need declared. `describe` reads what it shows
- * her now. `ask` names a method from the describe she read in this ask,
- * which says whether it is awaited or an effect.
- */
-export interface Undeclared<R extends string = string> {
-    describe(): Promise<{
-        readonly state: string;
-        readonly asks: readonly Described[];
-    }>;
-    ask(method: string, args?: Passed, options?: {
-        reply?: R;
-        after?: unknown;
-    }): Promise<unknown> | undefined;
-}
-/** What a far public being is reached by: her ward, and her addresses in order. */
-export interface Card {
-    readonly ward: string;
-    readonly at: readonly string[];
-}
-/**
- * A far public being asked as a stranger with no need declared. `describe`
- * reads what she shows a stranger now, and `ask` names a method from it.
- */
-export interface Strange {
-    describe(): Promise<{
-        readonly state: string;
-        readonly asks: readonly Described[];
-    }>;
-    ask(method: string, args?: Passed): Promise<unknown>;
-}
-/** What `this.house` gives every being. */
-export interface HouseReach<R extends string = string> {
-    now(): number;
-    random(options: {
-        length: number;
-    }): Uint8Array;
-    alarm(options: {
-        at: number;
-        ask: R;
-        args?: Json;
-        key: string;
-    }): void;
-    cancelAlarm(options: {
-        key: string;
-    }): void;
-}
-/** Her standings. */
-export interface Standings {
-    /** Each standing, with the domains that vouch for a far one's ward. */
-    list(): readonly (Relation & {
-        readonly vouched: readonly string[];
-    })[];
-    note(id: string, notes: Notes): void;
-    drop(id: string): void;
-}
-/** Her occupants and handles. */
-export interface Occupants {
-    list(): readonly Relation[];
-    note(id: string, notes: Notes): void;
-    dismiss(id: string): void;
-}
-/** The steward's six powers. */
-export interface Powers {
-    /** A new occupant of another being, as a handle she may pass on. */
-    invite(options: {
-        id: string;
-        occupant: string;
-        notes?: Notes;
-        expires?: number;
-    }): Handle;
-    bear(options: {
-        kind: string;
-        id: string;
-        args?: Json;
-    }): void;
-    remove(options: {
-        id: string;
-    }): void;
-    /** Every being, her kind, whether she is absent, and the replies her table refused. */
-    list(): Promise<readonly {
-        id: string;
-        kind: string;
-        absent: boolean;
-        dead: readonly {
-            ask: string;
-            args: Json;
-            at: number;
-            why: string;
-        }[];
-    }[]>;
-    /** Her args may carry a handle she holds or an invitation she carries, as any call outward. */
-    ask(call: {
-        id: string;
-        method: string;
-        args?: Passed;
-    }, options?: {
-        reply?: string;
-    }): Promise<unknown> | void;
-    /** With no method, the empty ask: what the being shows her steward now. */
-    ask(call: {
-        id: string;
-    }): Promise<{
-        readonly state: string;
-        readonly asks: readonly Described[];
-    }>;
-    introduce(options: {
-        from: string;
-        to: string;
-        notes?: Notes;
-    }): void;
-}
-export declare const DECLARATION: unique symbol;
-declare const ASKS: unique symbol;
-/** The asks of a class, carried in its type alone. */
-export interface Typed<A> {
-    readonly [ASKS]?: A;
-}
-type AskOf<T, K> = T extends Typed<infer A> ? (K extends keyof A ? A[K] : never) : never;
-/** The args her method `K` receives. */
-export type Args<T, K extends string> = AskOf<T, K> extends {
-    readonly args: infer S;
-} ? Inbound<Infer<S>> : Record<string, never>;
-/** What her method `K` answers. */
-export type Result<T, K extends string> = AskOf<T, K> extends {
-    readonly result: infer S;
-} ? Outbound<Infer<S>> : void;
-/** What every being reaches. */
-export declare abstract class Being<C = Record<string, Json>, R extends string = string> {
-    readonly id: string;
-    readonly position: Position;
-    readonly asker: Asker;
-    cells: C;
-    readonly house: HouseReach<R>;
-    readonly standings: Standings;
-    readonly occupants: Occupants;
-    /** Her steward, asked as a standing, where she is not one. */
-    readonly steward?: Untyped;
-    /** The house's powers, where she is the steward. */
-    readonly powers?: Powers;
-    /**
-     * A standing matched to a need; with none, a standing she reads first,
-     * then asks by any ask its describe showed her.
-     */
-    held: (<X extends Need>(id: string, need: X) => Face<X, R>) & ((id: string) => Undeclared<R>);
-    /**
-     * A far house's public being, reached by its ward and its addresses and
-     * asked as a stranger. Every ask is awaited, and signed with a key her
-     * house keeps for that ward alone. With no need, she reads its describe
-     * first, then asks by any ask it showed her.
-     */
-    stranger: (<X extends Need>(card: Card, need: X) => Face<X, R>) & ((card: Card) => Strange);
-    /**
-     * A handle to one of her asks. Each invitation it leaves as is spent within
-     * `expires` milliseconds of leaving, or never binds.
-     */
-    handle: (ask: R, options?: {
-        bind?: Json;
-        notes?: Notes;
-        once?: boolean;
-        expires?: number;
-    }) => Handle;
-    /** A new occupant, as a handle, with `expires` as `handle` has it. */
-    invite: (id: string, options?: {
-        notes?: Notes;
-        expires?: number;
-    }) => Handle;
-    /** Throws an error the asker can act on. */
-    fail: (message: string) => never;
-    /** A class, declared by one object. */
-    static of<C extends Record<string, Json> = Record<string, never>, const N extends Record<string, Need> = Record<never, never>, const A extends Record<string, Entry> = Record<string, Entry>>(declaration: Declaration<C, N, A>): BeingClass<C, N, A>;
-}
-/** What `Being.of` gives: a class to extend. */
-export type BeingClass<C, N, A> = (abstract new () => Being<C, keyof A & string> & {
-    readonly [K in keyof N]: Face<N[K], keyof A & string>;
-} & Typed<A>) & {
-    readonly [DECLARATION]: Declaration<C, N, A>;
-};
-/** The members of `Being` a class may not name. */
-export declare const MEMBERS: ReadonlySet<string>;
-/** The declaration a class carries, or nothing where it is no class of `Being.of`. */
-export declare const declarationOf: (value: unknown) => Declaration | undefined;
-export {};

package/dist/being/being.js

@@ -1,20 +0,0 @@
-export const DECLARATION = Symbol('declaration');
-/** What every being reaches. */
-export class Being {
-    /** A class, declared by one object. */
-    static of(declaration) {
-        // A class of her own, so the house reads her declaration from it.
-        class Declared extends Being {
-            static [DECLARATION] = declaration;
-        }
-        return Declared;
-    }
-}
-/** The members of `Being` a class may not name. */
-export const MEMBERS = new Set(['id', 'position', 'asker', 'cells', 'house', 'standings', 'occupants', 'steward', 'powers', 'held', 'stranger', 'handle', 'invite', 'fail']);
-/** The declaration a class carries, or nothing where it is no class of `Being.of`. */
-export const declarationOf = (value) => {
-    if (typeof value !== 'function' || !(value.prototype instanceof Being))
-        return undefined;
-    return value[DECLARATION];
-};

package/dist/being/covers.d.ts

@@ -1,9 +0,0 @@
-import type { Blueprint } from './need.ts';
-/** Covered, or the first rule that fails, as a sentence. */
-export type Cover = {
-    readonly covered: true;
-} | {
-    readonly covered: false;
-    readonly why: string;
-};
-export declare const covers: (offer: Blueprint, want: Blueprint) => Cover;

package/dist/being/covers.js

@@ -1,21 +0,0 @@
-const requiredOf = (schema) => {
-    const required = schema.required;
-    return Array.isArray(required) ? required : [];
-};
-export const covers = (offer, want) => {
-    if (offer.name !== want.name)
-        return { covered: false, why: `the offer is ${offer.name}, and the need is ${want.name}` };
-    for (const [name, wanted] of Object.entries(want.methods)) {
-        const offered = offer.methods[name];
-        if (offered === undefined)
-            return { covered: false, why: `${want.name} offers no ${name}` };
-        const sent = new Set(requiredOf(wanted.args));
-        const extra = requiredOf(offered.args).find((key) => !sent.has(key));
-        if (extra !== undefined)
-            return { covered: false, why: `${want.name}.${name} requires ${extra}, which the need does not send` };
-        if (offered.hints.idempotent !== wanted.hints.idempotent) {
-            return { covered: false, why: `${want.name}.${name} is idempotent in one and not the other` };
-        }
-    }
-    return { covered: true };
-};

package/dist/being/index.d.ts

@@ -1,4 +0,0 @@
-export { Being, type Args, type Json, type Result } from './being.ts';
-export { need } from './need.ts';
-export { s } from './schema.ts';
-export { resolve as tableOf, type Table } from './table.ts';

package/dist/being/index.js

@@ -1,6 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// `nervur/being`: what a being's author imports, and nothing else.
-export { Being } from './being.js';
-export { need } from './need.js';
-export { s } from './schema.js';
-export { resolve as tableOf } from './table.js';