@estiva-app/interop 0.1.0

package/dist/projection.d.ts

@@ -0,0 +1,524 @@
+/**
+ * Rendering another app's objects from its published manifest — the pure part.
+ *
+ * Split from `foreign.ts` so it can be exercised against a live relay without a
+ * Convex deployment: everything here takes a `query` function rather than
+ * reaching for one. `foreign.ts` supplies the authenticated bridge; a test
+ * supplies its own.
+ *
+ * **Nothing in this file knows what Linear-lite is.** No kind number, no field
+ * name, no status vocabulary is hardcoded — every one comes off the NIP-89
+ * manifest at runtime. If that stops being true the demo stops proving
+ * anything: it becomes an integration written against one app, which is the
+ * thing the whole exercise argues against.
+ */
+import { type AddressPointer } from '@estiva-app/protocol';
+import { type Profile, type SignedEvent } from '@estiva-app/protocol';
+/** Query the relay. Returns matching events; shape mirrors the HTTP bridge. */
+export type QueryFn = (filters: Record<string, unknown>[]) => Promise<SignedEvent[]>;
+/** An unsigned Nostr event, ready for `sign.ts`. */
+export interface UnsignedActionEvent {
+    pubkey: string;
+    created_at: number;
+    kind: number;
+    tags: string[][];
+    content: string;
+}
+/**
+ * The people named on another app's objects (FEE-1).
+ *
+ * A manifest says a slot holds a pubkey; it never says whose. Peek showed the
+ * first eight characters of the key, which is not a person — it is the thing a
+ * person is behind. The name and face come from kind:0, the same place the
+ * message list already gets them, so the same person reads the same way in both.
+ *
+ * Keyed by pubkey. A key that resolves to nothing is simply absent, and the
+ * renderer decides what an unknown person looks like.
+ */
+export type People = Record<string, Profile>;
+/**
+ * Looking people up, as a seam rather than a direct call.
+ *
+ * The browser puts a session cache in front of this: a topic with ten reference
+ * widgets resolves ten times, and it is the same handful of people every time.
+ * Tests and Storybook pass a fixture instead and never touch a relay.
+ */
+export type PeopleFn = (pubkeys: string[]) => Promise<People>;
+/** The default: one kind:0 query, straight to the relay. */
+export declare function peopleViaRelay(query: QueryFn): PeopleFn;
+/**
+ * Every kind an app's comments might be under — what it publishes **now**, plus
+ * any it has published before.
+ *
+ * `emits.kind` is a single number, and for a while that was enough. It stops
+ * being enough the moment an app *changes* the kind it emits, because the old
+ * events do not move: a `kind:9` message is not replaceable at all, so a comment
+ * written under the old kind stays under it permanently. Reading only the
+ * declared kind would show an object's newest comments and silently drop every
+ * one written before the change — no error, nothing empty, just a thread that
+ * begins in the middle.
+ *
+ * So the owning app may also declare `emits.alsoRead`, which is the kinds it
+ * used to publish. That is the only place the knowledge actually lives; the
+ * alternative is Peek hardcoding one app's history, which is exactly what the
+ * note on `KIND_COMMENT` above says not to do.
+ *
+ * Absent `alsoRead` this returns a single kind, so a manifest written before
+ * the field existed behaves exactly as it did.
+ */
+export declare function commentKindsOf(manifest: Manifest): number[];
+/** How the owning app says its records should be read. */
+interface RecordsRule {
+    changeKind: number;
+    targetTag: string;
+    fieldTag: string;
+    valueTag: string;
+    order: string[];
+    rule: string;
+    /**
+     * A folded field whose value means "do not show this object".
+     *
+     * Archiving is a field, not a deletion, so an archived record still comes
+     * back from every query and renders perfectly well. Without this a consumer
+     * cannot tell it apart from live work — which is how a topic whose Folder
+     * held three archived projects ended up showing one of them.
+     *
+     * Peek honours the rule without knowing what the word means: the owner says
+     * which field and which value, and this stays out of it.
+     */
+    hiddenWhen?: {
+        field: string;
+        equals: string;
+    };
+}
+interface SlotSpec {
+    /**
+     * A tag on the root event, or a list of them meaning **first that resolves**.
+     *
+     * A list exists for the same reason `emits.alsoRead` does: an app that
+     * renames a tag cannot rename it on the events it already published, so its
+     * history spans both spellings permanently. Ship moving a project's title
+     * from `title` to `name` is the case in hand — without a fallback, either
+     * every record written before the rename renders blank or every one written
+     * after does.
+     *
+     * Not to be confused with a `SlotSpec[]`, which the caller treats as "render
+     * all of these as meta". This is one slot with several places to look.
+     */
+    tag?: string | string[];
+    field?: string;
+    fold?: string;
+    map?: string;
+    as?: string;
+    label?: string;
+    truncate?: number;
+    default?: string;
+    /**
+     * **Child objects, found by the tag on the child that names this one.**
+     *
+     * The `list` slot (RFC 0.4 §13.3, PRO-2). The only slot source that does not
+     * read the root event: every other field here answers "what does this event
+     * say?", and this one answers "what points at it?".
+     *
+     * `limit` is the producer saying how many are worth fetching. **Recursion
+     * depth is deliberately not here** — a child rendered through its own
+     * projection may declare a `list` too, and the app at risk of the render loop
+     * is the one drawing it, so the budget is the consumer's (`MAX_LIST_DEPTH`).
+     * §13.4's honour-system rule cuts that way: a producer that could set the
+     * consumer's recursion budget could hang it.
+     */
+    children?: {
+        kind: number;
+        via: string;
+        limit?: number;
+        /**
+         * What the child's `via` tag holds — added by PRO-6.
+         *
+         * `address` (the default, and Ship's case) means the tag carries the
+         * parent's full `kind:pubkey:d`. `identifier` means it carries only the
+         * parent's `d`.
+         *
+         * Found by declaring a projection for a Peek Topic. A message names its
+         * channel with `h`, and `h` holds the **bare channel uuid** — which is the
+         * topic's `d`, not its address. Nothing in NIP-29 is going to change that,
+         * so a `list` slot that could only compare addresses could not express the
+         * one relationship Peek has. Defaulting to `address` keeps every manifest
+         * written before this reading exactly as it did.
+         */
+        match?: 'address' | 'identifier';
+    };
+}
+/** An action the owning app says other apps may perform. */
+export interface ManifestAction {
+    id: string;
+    label: string;
+    /** Kind(s) this applies to, as strings. */
+    appliesTo: string | string[];
+    emits: {
+        kind: number;
+        field?: string;
+        scope?: string;
+        /**
+         * Set by an action that creates a whole new object under this one: the tag
+         * the child carries, and what it points at. `toAddressOf: "self"` means the
+         * child names the object the action was invoked on.
+         *
+         * Peek reads these two to learn a **containment relation** — "kind X holds
+         * kind Y" — without being told which app or which kinds are involved. It is
+         * the only thing in the manifest that says so, which is what lets the
+         * sidebar start from a Folder and find a project with issues in it.
+         */
+        setTag?: string;
+        toAddressOf?: string;
+        /**
+         * Kinds this action *used* to emit, which consumers must still read.
+         *
+         * Only ever additive to a read, never to a write: `kind` is what gets
+         * published, this is what also gets fetched. See `commentKindsOf`.
+         */
+        alsoRead?: number[];
+    };
+    input?: {
+        type: string;
+        enum?: string;
+    };
+}
+/**
+ * An action resolved into something a renderer can draw without re-reading the
+ * manifest.
+ *
+ * The interpretation happens here rather than in the component on purpose: the
+ * widget should not have to know that `input.enum` names a vocabulary, or that
+ * `as: "pubkey"` means "a person". Those are manifest semantics, and keeping
+ * them on this side is what lets the React component stay a dumb renderer that
+ * would work for any app.
+ */
+export interface ResolvedAction {
+    id: string;
+    label: string;
+    control: 'select' | 'pubkey' | 'text';
+    /** For `select`: the declared vocabulary, already looked up. */
+    options?: {
+        value: string;
+        label: string;
+        colour?: string;
+    }[];
+    /** The value this field holds right now, so a control can show it. */
+    current?: string;
+    field?: string;
+}
+interface Manifest {
+    name?: string;
+    about?: string;
+    actions?: ManifestAction[];
+    records?: RecordsRule;
+    projections?: Record<string, {
+        widget: string | string[];
+        slots: Record<string, SlotSpec | SlotSpec[]>;
+    }>;
+    vocabularies?: Record<string, {
+        value: string;
+        label: string;
+        colour: string;
+        stage?: string;
+    }[]>;
+}
+export declare function resolveManifest(pointer: AddressPointer, query: QueryFn): Promise<{
+    manifest: Manifest;
+    address: string;
+    viaRecommendation: boolean;
+    /** NIP-89 `web` template, `<bech32>` not yet substituted. */
+    webTemplate?: string;
+} | null>;
+/**
+ * Which layout to draw, from a declared type or an ordered chain of them.
+ *
+ * RFC 0.4 §13.3. A widget is a layout *hint* rather than a semantic, so an
+ * unknown one can degrade honestly: `["message", "card"]` means *render me as a
+ * message if you know it, else as a card*, and a chain must terminate in a type
+ * the spec closes.
+ *
+ * **It lives here rather than in each consumer** because two implementations
+ * would disagree the first time a chain had three entries, and the whole point
+ * of the chain is that producers and consumers upgrade at different times. The
+ * consumer supplies what it implements; the runtime does the walking.
+ *
+ * `fallback` is what to draw when the chain runs out — never "nothing". §13.3's
+ * argument is that a blank object is indistinguishable from one the reader may
+ * not be allowed to see, and reports "that app is broken" about an app doing
+ * exactly what it was told.
+ */
+/**
+ * The widget types RFC 0.4 §13.3 closes. A chain MUST end in one of these.
+ *
+ * Exported because both halves need the same list and they must not drift: a
+ * producer checks its chain terminates here, a consumer's fallback is drawn
+ * from here. Two copies would disagree the first time the set grew, and the
+ * disagreement would show up as an object rendering blank in one app only.
+ */
+export declare const CLOSED_WIDGETS: readonly ["card", "row", "table", "stat"];
+/**
+ * Why a widget declaration is not publishable, or null when it is — PRO-3.
+ *
+ * **The producer half of the fallback chain.** `pickWidget` below makes a
+ * consumer safe against a chain it does not fully understand; this stops the
+ * unrenderable chain being published in the first place. Both are needed and
+ * they fail differently: without the consumer half an unknown widget renders
+ * blank, and without this one a *conformant* consumer renders blank through no
+ * fault of its own, having done exactly what it was told.
+ *
+ * A chain that does not terminate in a closed type is the PEE-10 failure with
+ * a longer fuse — every consumer that has not heard of `profile` walks
+ * `["profile"]` to the end and has nothing left to draw.
+ *
+ * Returns a sentence rather than a boolean because this is read by a person
+ * publishing a manifest, and "invalid widget" tells them nothing about which
+ * one or what to do.
+ */
+export declare function widgetChainProblem(declared: unknown): string | null;
+export declare function pickWidget<T extends string>(declared: string | string[], implemented: readonly T[], fallback: T): T;
+/** A slot, resolved to something a renderer can put on screen. */
+export interface ResolvedSlot {
+    label?: string;
+    value: string;
+    /** Set when the value came from a vocabulary — the consumer picks the colour. */
+    colour?: string;
+    /** True when the value is a pubkey and should be shown as a person. */
+    isPubkey?: boolean;
+    /**
+     * The underlying field this slot reads, when it has a name.
+     *
+     * Carried so a renderer can tell that a slot and an action are two views of
+     * *one* value — a status label beside a status picker is the same fact twice
+     * (PEEK-18). Matching on the field is what makes that check work for any app:
+     * the slot key (`status`) and the action's label ("Change status") are both
+     * free-form, but a `ResolvedAction.field` and this always name the same thing
+     * because the manifest wrote them both.
+     *
+     * Undefined for a slot with no named source — `{field: "content"}` reads the
+     * event body, which no action can set.
+     */
+    field?: string;
+}
+/** Everything the frontend needs to draw the widget. */
+export interface ForeignObject {
+    /**
+     * A stable unique handle for this object, whatever kind of thing it is.
+     *
+     * **Added by PRO-7, and it exists because not every object has an address.**
+     * A replaceable record is identified by `kind:pubkey:d`; a regular event —
+     * Peek's `kind:9` message is the case in hand — has no `d` at all and is
+     * identified only by its event id. Before this, `address` was required and
+     * doubled as the React key, the error-map key and the `data-` attribute, so
+     * a non-addressable object could not be represented at all.
+     *
+     * Use this for identity. Use `naddr` only where an *address* is genuinely
+     * required, which in practice means acting on an object.
+     */
+    ref: string;
+    /**
+     * The address, `kind:pubkey:d` — **only for an addressable object.**
+     *
+     * Undefined for a regular event. See `ref`.
+     */
+    address?: string;
+    /**
+     * The address as `naddr1…`, **only for an addressable object.**
+     *
+     * Carried alongside `address` because acting on an object is addressed by
+     * naddr (`act.ts`), and the sidebar builds its objects rather than being
+     * handed a reference somebody pasted. Without it every control in a
+     * sidebar card would have to re-encode what the server already knows.
+     *
+     * Its absence is meaningful rather than a gap: an action emits a change
+     * carrying an `a` tag, and there is nothing for that tag to point at on a
+     * non-addressable object. A consumer that has no `naddr` correctly offers no
+     * actions.
+     */
+    naddr?: string;
+    /** The event id — set for every object, and the only handle a regular event has. */
+    eventId: string;
+    /**
+     * Child objects from a `list` slot, each resolved through its own projection.
+     *
+     * Empty rather than absent when the slot is declared and nothing matched, so
+     * a renderer can tell "this holds nothing" from "this holds no list".
+     */
+    children?: ForeignObject[];
+    kind: number;
+    /**
+     * The layout hint the owner declared — **a type or an ordered chain of them.**
+     *
+     * `["message", "card"]` means *render me as a message if you know it, else as
+     * a card*, and a chain MUST terminate in a type RFC 0.4 §13.3 closes
+     * (`card`/`row`/`table`/`stat`). A bare string is the older form and is a
+     * chain of one.
+     *
+     * **This was typed `string` until PRO-7**, while Peek's own published manifest
+     * declares `["message","card"]` — so the type said one thing and the wire said
+     * another, and a consumer writing `widget === 'card'` compared a string to an
+     * array and silently drew nothing. Found by Ship, the second consumer, the
+     * first time anything typechecked a renderer against a real chain. That is
+     * the answer to PRO-1's "what did the second consumer force to change".
+     */
+    widget: string | string[];
+    appName?: string;
+    /** Named single slots: title, subtitle, status. */
+    slots: Record<string, ResolvedSlot>;
+    /** Repeating slots, e.g. `meta`. */
+    meta: ResolvedSlot[];
+    comments: {
+        id: string;
+        author: string;
+        body: string;
+        createdAt: number;
+    }[];
+    /**
+     * The Folder this object lives in, from the root event's `h` tag.
+     *
+     * Needed to *write*: a change event carries the same `h`, and without it the
+     * relay rejects the write outright. Reading it off the object rather than
+     * asking the user is the difference between an action that works and a form
+     * with a "Folder id" box in it.
+     */
+    folder?: string;
+    /**
+     * Where to open this object in the app that owns it, from NIP-89's `web` tag.
+     *
+     * The return leg of the roundtrip. Without it a reference is a read-only
+     * snapshot: Peek can render a Linear-lite issue and change its status, and
+     * getting back to the issue itself means alt-tabbing and hunting for a row.
+     *
+     * Absent when the owning app published no template — the widget simply does
+     * not offer the link, rather than guessing a URL.
+     */
+    openUrl?: string;
+    /** What the owning app says we may do to this object. */
+    actions: ResolvedAction[];
+    /**
+     * Names and faces for every pubkey this object shows (FEE-1).
+     *
+     * Carried on the object rather than looked up by the renderer so a widget is
+     * still a pure render of what it was handed — the same property that lets
+     * Storybook draw a real person from a fixture. Empty when nothing published a
+     * profile, which the renderer treats as "someone we cannot name" rather than
+     * falling back to the key.
+     */
+    people?: People;
+    /** False when no author recommendation existed and a handler was guessed. */
+    viaRecommendation: boolean;
+    /**
+     * Set when the manifest resolved but the object itself did not.
+     *
+     * Almost always a permission problem rather than a missing object, and worth
+     * distinguishing because the relay makes them look identical. Objects and
+     * change events are channel-scoped, so a reader who is not a member of the
+     * Folder gets zero rows — no error, just silence. The manifest and the
+     * recommendation are global kinds and resolve fine without membership, so the
+     * failure lands late and presents as a broken reference. Telling the user
+     * "you may not have access to this Folder" is a far better guess than
+     * rendering nothing.
+     */
+    unreachable?: boolean;
+}
+/**
+ * Resolve a `nostr:naddr…` into a renderable widget.
+ *
+ * Returns `null` rather than throwing when the object cannot be rendered — an
+ * unresolvable reference in a chat message should degrade to plain text, not
+ * break the message around it.
+ */
+export declare function resolveForeignObject(naddr: string, query: QueryFn, 
+/** Defaults to asking the relay. The browser passes a cached lookup. */
+lookupPeople?: PeopleFn, 
+/**
+ * How many `list` levels have already been followed. Callers outside this
+ * module leave it at 0; it is the budget that stops a child's own `list`
+ * recursing forever. See `MAX_LIST_DEPTH`.
+ */
+depth?: number): Promise<ForeignObject | null>;
+/**
+ * A Folder's project and the tickets in motion in it.
+ *
+ * Both are ordinary `ForeignObject`s — the same shape an `naddr` in a message
+ * resolves to, carrying the same slots, the same declared actions and the same
+ * link back into the owning app. The sidebar therefore renders the owning app's
+ * objects with the owning app's affordances rather than a reduced copy of them,
+ * and a ticket is as actionable there as it is inline in a conversation.
+ */
+export interface FolderProject {
+    project: ForeignObject;
+    /**
+     * Every ticket in the project, finished or not: started work first, then the
+     * queue, then what is done. Archived ones are left out — an app hiding a
+     * record from its own lists is saying it is no longer part of the project.
+     */
+    tickets: ForeignObject[];
+    /** Tickets still to do. With `doneCount`, the total the panel counts against. */
+    openCount: number;
+    /** Finished tickets — the numerator in the panel's "1/3". */
+    doneCount: number;
+}
+/**
+ * The project living in a Folder, plus the work currently in motion in it.
+ *
+ * Starts from a **Folder** rather than an naddr, which is the difference
+ * between this and `resolveForeignObject`: a Peek topic and a Linear-lite
+ * project are one container (RFC_UPDATES.md §1.1), so a topic already knows
+ * enough to ask "what project is this?" without anyone pasting a reference.
+ *
+ * Still knows nothing about Linear-lite. Which kind is a project, which kind is
+ * an issue, how they link, how status folds and what it is called all come off
+ * published manifests at runtime — the same discipline as the rest of this file.
+ *
+ * Returns null for "nothing to show": no manifest declares a container, no
+ * project in this Folder and none named by the tickets in it, or the object
+ * cannot be read. All of those are ordinary states the caller renders as an
+ * empty sidebar, not errors.
+ */
+export declare function resolveFolderProject(folder: string, query: QueryFn, 
+/** Defaults to asking the relay. The browser passes a cached lookup. */
+lookupPeople?: PeopleFn, 
+/**
+ * How many `list` levels have already been followed to get here. Callers
+ * outside this module leave it at 0; it exists so that following a child's
+ * own `list` is a budget check rather than a thing nobody remembered.
+ */
+depth?: number): Promise<FolderProject | null>;
+/**
+ * Build the event that performs a manifest-declared action.
+ *
+ * Pure, and separate from the Convex action for the same reason `projection.ts`
+ * is separate from `foreign.ts`: this is the part worth testing against a live
+ * relay, and it must not need a deployment or a signed-in session to run.
+ *
+ * Returns a string on refusal rather than throwing — every failure here is
+ * something a user should read.
+ */
+export declare function buildActionEvent(args: {
+    manifest: {
+        records?: RecordsRule;
+        actions?: ManifestAction[];
+        vocabularies?: Manifest['vocabularies'];
+    };
+    kind: number;
+    /** Address of the object being acted on. */
+    address: string;
+    /** Author of the object — needed for NIP-22's `P`/`p` tags. */
+    objectAuthor: string;
+    folder: string;
+    actionId: string;
+    value: string;
+    pubkey: string;
+    createdAtMs: number;
+}): UnsignedActionEvent | string;
+/**
+ * Test seam: resolve one projection's `title` slot against one event.
+ *
+ * Exported so the tag-fallback rules can be pinned without standing up a fake
+ * relay. `resolveSlots` and `resolveSlot` are the real path; this only picks
+ * the one slot out of them.
+ */
+export declare function resolveFolderProjectSlotsForTest(manifest: Manifest, root: SignedEvent): string | undefined;
+export {};
+//# sourceMappingURL=projection.d.ts.map

package/dist/projection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"projection.d.ts","sourceRoot":"","sources":["../src/projection.ts"],"names":[],"mappings":"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"}