@pyric/ui 0.1.0-alpha.7

package/dist/events/hooks/useActivityDigest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useActivityDigest.d.ts","sourceRoot":"","sources":["../../../src/events/hooks/useActivityDigest.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AACpD,OAAO,EAEL,KAAK,cAAc,EACnB,KAAK,qBAAqB,EAC3B,MAAM,cAAc,CAAC;AAEtB,MAAM,WAAW,wBAAyB,SAAQ,qBAAqB;IACrE;;;;;;;;OAQG;IACH,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,SAAS,gBAAgB,EAAE,EACnC,OAAO,GAAE,wBAA6B,GACrC,cAAc,CAMhB"}

package/dist/events/hooks/useActivityDigest.js

@@ -0,0 +1,18 @@
+import { useMemo } from 'react';
+import { computeActivityDigest, } from '../digest.js';
+/**
+ * React wrapper over {@link computeActivityDigest} — memoizes the pure
+ * fold over the unified `SandboxEvent` stream into the banded activity
+ * digest. Feed it `sandbox.history()` (a snapshot) or the live buffer
+ * from {@link useActivityStream}; the reducer is identical either way.
+ *
+ * The fold re-runs when `events` identity, any grouping option, or
+ * `now` changes. Keep `events` referentially stable across renders that
+ * shouldn't recompute (the stream hook already returns a stable array
+ * per emission).
+ */
+export function useActivityDigest(events, options = {}) {
+    const { order, groupBy, rowsPerBand, now } = options;
+    return useMemo(() => computeActivityDigest(events, { order, groupBy, rowsPerBand, now }), [events, order, groupBy, rowsPerBand, now]);
+}
+//# sourceMappingURL=useActivityDigest.js.map

package/dist/events/hooks/useActivityDigest.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useActivityDigest.js","sourceRoot":"","sources":["../../../src/events/hooks/useActivityDigest.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,OAAO,CAAC;AAEhC,OAAO,EACL,qBAAqB,GAGtB,MAAM,cAAc,CAAC;AAetB;;;;;;;;;;GAUG;AACH,MAAM,UAAU,iBAAiB,CAC/B,MAAmC,EACnC,UAAoC,EAAE;IAEtC,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,WAAW,EAAE,GAAG,EAAE,GAAG,OAAO,CAAC;IACrD,OAAO,OAAO,CACZ,GAAG,EAAE,CAAC,qBAAqB,CAAC,MAAM,EAAE,EAAE,KAAK,EAAE,OAAO,EAAE,WAAW,EAAE,GAAG,EAAE,CAAC,EACzE,CAAC,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,WAAW,EAAE,GAAG,CAAC,CAC3C,CAAC;AACJ,CAAC"}

package/dist/events/hooks/useActivityStream.d.ts

@@ -0,0 +1,44 @@
+import type { ActivitySource, AnyActivityEvent } from '../types.js';
+export interface UseActivityStreamOptions {
+    /**
+     * The subscription — `sandbox.onEvent` satisfies this directly. Pass
+     * a stable reference; the hook re-subscribes on identity change.
+     */
+    source: ActivitySource;
+    /**
+     * Seed the buffer with a snapshot before the live subscription
+     * attaches — typically `sandbox.history()`, so a late-attaching
+     * consumer sees the whole session, not just events from `subscribe`
+     * onward. Read once on mount.
+     */
+    initial?: readonly AnyActivityEvent[];
+    /**
+     * Ring-buffer cap. Once exceeded, the oldest events drop. Default
+     * 5000 (mirrors the traffic monitor's cap — a load-test session can
+     * emit 100k+ events).
+     */
+    bufferSize?: number;
+    /** Start paused — incoming events drop (not queued) while paused. */
+    paused?: boolean;
+}
+export interface UseActivityStreamResult {
+    /** The buffered events, oldest-first. Stable per emission — safe to
+     *  hand straight to {@link useActivityDigest}. */
+    events: AnyActivityEvent[];
+    isPaused: boolean;
+    pause: () => void;
+    resume: () => void;
+    /** Empty the buffer (does NOT re-seed from `initial`). */
+    clear: () => void;
+}
+/**
+ * Buffers the unified sandbox event stream into a capped ring buffer
+ * with optional history seeding + pause/resume/clear. Decoupled from
+ * `pyric` — `source` is just a `(cb) => unsubscribe`.
+ *
+ * Sibling to the traffic monitor's `useTrafficMonitor`; the difference
+ * is the wider event type (`AnyActivityEvent`, the full union) and the
+ * `initial` seed so `history()` + live compose into one buffer.
+ */
+export declare function useActivityStream({ source, initial, bufferSize, paused, }: UseActivityStreamOptions): UseActivityStreamResult;
+//# sourceMappingURL=useActivityStream.d.ts.map

package/dist/events/hooks/useActivityStream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useActivityStream.d.ts","sourceRoot":"","sources":["../../../src/events/hooks/useActivityStream.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAEpE,MAAM,WAAW,wBAAwB;IACvC;;;OAGG;IACH,MAAM,EAAE,cAAc,CAAC;IACvB;;;;;OAKG;IACH,OAAO,CAAC,EAAE,SAAS,gBAAgB,EAAE,CAAC;IACtC;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,qEAAqE;IACrE,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,WAAW,uBAAuB;IACtC;sDACkD;IAClD,MAAM,EAAE,gBAAgB,EAAE,CAAC;IAC3B,QAAQ,EAAE,OAAO,CAAC;IAClB,KAAK,EAAE,MAAM,IAAI,CAAC;IAClB,MAAM,EAAE,MAAM,IAAI,CAAC;IACnB,0DAA0D;IAC1D,KAAK,EAAE,MAAM,IAAI,CAAC;CACnB;AAED;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAAC,EAChC,MAAM,EACN,OAAO,EACP,UAAiB,EACjB,MAAc,GACf,EAAE,wBAAwB,GAAG,uBAAuB,CAkCpD"}

package/dist/events/hooks/useActivityStream.js

@@ -0,0 +1,38 @@
+import { useEffect, useMemo, useRef, useState } from 'react';
+/**
+ * Buffers the unified sandbox event stream into a capped ring buffer
+ * with optional history seeding + pause/resume/clear. Decoupled from
+ * `pyric` — `source` is just a `(cb) => unsubscribe`.
+ *
+ * Sibling to the traffic monitor's `useTrafficMonitor`; the difference
+ * is the wider event type (`AnyActivityEvent`, the full union) and the
+ * `initial` seed so `history()` + live compose into one buffer.
+ */
+export function useActivityStream({ source, initial, bufferSize = 5000, paused = false, }) {
+    const [events, setEvents] = useState(() => initial ? initial.slice(-bufferSize) : []);
+    const [isPaused, setIsPaused] = useState(paused);
+    const pausedRef = useRef(isPaused);
+    pausedRef.current = isPaused;
+    const bufferSizeRef = useRef(bufferSize);
+    bufferSizeRef.current = bufferSize;
+    useEffect(() => {
+        const unsubscribe = source((event) => {
+            if (pausedRef.current)
+                return;
+            setEvents((prev) => {
+                const next = prev.length >= bufferSizeRef.current ? prev.slice(1) : prev.slice();
+                next.push(event);
+                return next;
+            });
+        });
+        return unsubscribe;
+    }, [source]);
+    return useMemo(() => ({
+        events,
+        isPaused,
+        pause: () => setIsPaused(true),
+        resume: () => setIsPaused(false),
+        clear: () => setEvents([]),
+    }), [events, isPaused]);
+}
+//# sourceMappingURL=useActivityStream.js.map

package/dist/events/hooks/useActivityStream.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useActivityStream.js","sourceRoot":"","sources":["../../../src/events/hooks/useActivityStream.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AAqC7D;;;;;;;;GAQG;AACH,MAAM,UAAU,iBAAiB,CAAC,EAChC,MAAM,EACN,OAAO,EACP,UAAU,GAAG,IAAI,EACjB,MAAM,GAAG,KAAK,GACW;IACzB,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,GAAG,QAAQ,CAAqB,GAAG,EAAE,CAC5D,OAAO,CAAC,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,EAAE,CAC1C,CAAC;IACF,MAAM,CAAC,QAAQ,EAAE,WAAW,CAAC,GAAG,QAAQ,CAAC,MAAM,CAAC,CAAC;IAEjD,MAAM,SAAS,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAC;IACnC,SAAS,CAAC,OAAO,GAAG,QAAQ,CAAC;IAC7B,MAAM,aAAa,GAAG,MAAM,CAAC,UAAU,CAAC,CAAC;IACzC,aAAa,CAAC,OAAO,GAAG,UAAU,CAAC;IAEnC,SAAS,CAAC,GAAG,EAAE;QACb,MAAM,WAAW,GAAG,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE;YACnC,IAAI,SAAS,CAAC,OAAO;gBAAE,OAAO;YAC9B,SAAS,CAAC,CAAC,IAAI,EAAE,EAAE;gBACjB,MAAM,IAAI,GACR,IAAI,CAAC,MAAM,IAAI,aAAa,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC;gBACtE,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;gBACjB,OAAO,IAAI,CAAC;YACd,CAAC,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;QACH,OAAO,WAAW,CAAC;IACrB,CAAC,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC;IAEb,OAAO,OAAO,CACZ,GAAG,EAAE,CAAC,CAAC;QACL,MAAM;QACN,QAAQ;QACR,KAAK,EAAE,GAAG,EAAE,CAAC,WAAW,CAAC,IAAI,CAAC;QAC9B,MAAM,EAAE,GAAG,EAAE,CAAC,WAAW,CAAC,KAAK,CAAC;QAChC,KAAK,EAAE,GAAG,EAAE,CAAC,SAAS,CAAC,EAAE,CAAC;KAC3B,CAAC,EACF,CAAC,MAAM,EAAE,QAAQ,CAAC,CACnB,CAAC;AACJ,CAAC"}

package/dist/events/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * `@pyric/ui/events` — headless activity view over the unified
+ * `SandboxEvent` stream (Pyric Studio's keystone). Aggregates the whole
+ * stream (Firestore request/write + the cross-service `service_mutation`
+ * envelope for auth/storage/rtdb) into category bands with per-row
+ * provenance — the activity grid. Sibling to `@pyric/ui/traffic` (which
+ * is per-request, not aggregated-by-category).
+ *
+ * Ships zero styling — Pyric Studio applies the `data-pyric-*` contract.
+ */
+export * from './hooks/index.js';
+export * from './components/index.js';
+export { computeActivityDigest, type ActivityDigest, type ActivityDigestOptions, type ActivityGroupBy, type ActivityBand, type ActivityBandWithGroups, type ActivitySubgroup, type ActivityBandKey, type ActivityRow, } from './digest.js';
+export type { ActivityEvent, AnyActivityEvent, ActivitySource, ActivityRequestEvent, ActivityWriteEvent, ActivityServiceMutationEvent, ActivityProvenance, ActivityService, ActivityActor, ActivityLens, ActivityResult, ActivityAuthState, } from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/events/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/events/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,cAAc,kBAAkB,CAAC;AACjC,cAAc,uBAAuB,CAAC;AAEtC,OAAO,EACL,qBAAqB,EACrB,KAAK,cAAc,EACnB,KAAK,qBAAqB,EAC1B,KAAK,eAAe,EACpB,KAAK,YAAY,EACjB,KAAK,sBAAsB,EAC3B,KAAK,gBAAgB,EACrB,KAAK,eAAe,EACpB,KAAK,WAAW,GACjB,MAAM,aAAa,CAAC;AAErB,YAAY,EACV,aAAa,EACb,gBAAgB,EAChB,cAAc,EACd,oBAAoB,EACpB,kBAAkB,EAClB,4BAA4B,EAC5B,kBAAkB,EAClB,eAAe,EACf,aAAa,EACb,YAAY,EACZ,cAAc,EACd,iBAAiB,GAClB,MAAM,YAAY,CAAC"}

package/dist/events/index.js

@@ -0,0 +1,14 @@
+/**
+ * `@pyric/ui/events` — headless activity view over the unified
+ * `SandboxEvent` stream (Pyric Studio's keystone). Aggregates the whole
+ * stream (Firestore request/write + the cross-service `service_mutation`
+ * envelope for auth/storage/rtdb) into category bands with per-row
+ * provenance — the activity grid. Sibling to `@pyric/ui/traffic` (which
+ * is per-request, not aggregated-by-category).
+ *
+ * Ships zero styling — Pyric Studio applies the `data-pyric-*` contract.
+ */
+export * from './hooks/index.js';
+export * from './components/index.js';
+export { computeActivityDigest, } from './digest.js';
+//# sourceMappingURL=index.js.map

package/dist/events/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/events/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,cAAc,kBAAkB,CAAC;AACjC,cAAc,uBAAuB,CAAC;AAEtC,OAAO,EACL,qBAAqB,GAStB,MAAM,aAAa,CAAC"}

package/dist/events/types.d.ts

@@ -0,0 +1,160 @@
+/**
+ * The events/activity domain types. These are a local, structurally-
+ * compatible mirror of `pyric`'s unified `SandboxEvent` union (and its
+ * `EventProvenance`) — the `@pyric/ui` packages never import `pyric` so
+ * the headless layer stays decoupled from the sandbox impl (the same
+ * stance the sibling `traffic/` area takes with `RequestEvent`).
+ *
+ * `sandbox.onEvent` / `sandbox.history()` are assignable as an
+ * `ActivitySource` / `ActivityEvent[]` with zero adapter code: every
+ * field here is a subset (by name + shape) of the matching field on the
+ * sandbox type. A production audit feed satisfying the same shape works
+ * too.
+ *
+ * Unlike `traffic/` (which models only Firestore `request` events, one
+ * row per evaluated op), the events area aggregates the FULL stream —
+ * Firestore `request`/`write` plus the cross-service `service_mutation`
+ * envelope (auth / storage / rtdb) — into category bands. So the local
+ * types cover the union members the digest reads, not just one kind.
+ */
+/** Which sandbox service emitted an event. Absent ⇒ `'firestore'`. */
+export type ActivityService = 'firestore' | 'auth' | 'storage' | 'rtdb';
+/** Who initiated the op behind an event. Absent ⇒ the served app. */
+export type ActivityActor = {
+    kind: 'app';
+} | {
+    kind: 'studio';
+} | {
+    kind: 'agent';
+    name: string;
+} | {
+    kind: 'app-builder';
+};
+/**
+ * The auth lens an op ran under. `admin` bypasses rules, `as` evaluates
+ * rules as a specific uid (impersonation), `app-session` is the app's
+ * own signed-in user. Absent ⇒ `app-session`.
+ */
+export type ActivityLens = {
+    mode: 'admin';
+} | {
+    mode: 'as';
+    uid: string;
+} | {
+    mode: 'app-session';
+};
+/** Identity in effect for an op. `null` is anonymous / signed out. */
+export interface ActivityAuthState {
+    uid: string;
+    token?: Record<string, unknown>;
+}
+/**
+ * Provenance carried by every event. All optional + additive — pre-
+ * provenance emitters omit them (read as firestore / app / app-session).
+ */
+export interface ActivityProvenance {
+    service?: ActivityService;
+    actor?: ActivityActor;
+    authLens?: ActivityLens;
+    /** Set when the op is part of an agent plan (dry-run / accept). */
+    planId?: string;
+}
+/** Firestore op outcome — present on `request` events only. */
+export type ActivityResult = 'allow' | 'deny' | 'unsupported';
+/**
+ * A Firestore `request` event — one per evaluated op. The digest reads
+ * these for denials (`result === 'deny'`) and, when no `write` event is
+ * present, for the allow trail. Structurally a subset of `RequestEvent`.
+ */
+export interface ActivityRequestEvent extends ActivityProvenance {
+    kind: 'request';
+    id: string;
+    at: number;
+    method: 'get' | 'list' | 'create' | 'update' | 'set' | 'delete';
+    path: string;
+    auth: ActivityAuthState | null;
+    result: ActivityResult;
+    /** Simulator debug trail. Used to surface the deciding rule on denials. */
+    reasons: string[];
+    request?: {
+        resourceData?: Record<string, unknown>;
+    };
+    resourceBefore?: {
+        data: Record<string, unknown> | null;
+        exists: boolean;
+    };
+    resourceAfter?: {
+        data: Record<string, unknown> | null;
+        exists: boolean;
+    };
+    matchedRule?: {
+        ruleIndex: number;
+        operations: string[];
+    };
+    origin: 'user' | 'listener' | 'transaction' | 'batch';
+    groupId?: string;
+    triggeredBy?: {
+        method: string;
+        path: string;
+    };
+}
+/**
+ * A committed Firestore write — `create`/`update`/`set`/`delete` that
+ * the rule engine allowed and the keyspace applied. The digest leads
+ * with these for the added/updated/removed bands (richer than `request`:
+ * carries prior/next state for the change summary). Subset of
+ * `WriteSandboxEvent`.
+ */
+export interface ActivityWriteEvent extends ActivityProvenance {
+    kind: 'write';
+    id: string;
+    at: number;
+    method: 'create' | 'update' | 'set' | 'delete';
+    path: string;
+    auth: ActivityAuthState | null;
+    data?: Record<string, unknown>;
+    priorState: Record<string, unknown> | null;
+    nextState: Record<string, unknown> | null;
+    groupId?: string;
+}
+/**
+ * Cross-service mutation — the unified envelope auth / storage / rtdb
+ * emit. The digest maps `service` + `op` to a band (signed-in, added,
+ * updated, removed, …). Subset of `ServiceMutationEvent`.
+ */
+export interface ActivityServiceMutationEvent extends ActivityProvenance {
+    kind: 'service_mutation';
+    id: string;
+    at: number;
+    service: 'auth' | 'storage' | 'rtdb';
+    op: string;
+    path?: string;
+    auth: ActivityAuthState | null;
+    before?: unknown;
+    after?: unknown;
+    detail?: Record<string, unknown>;
+}
+/**
+ * The union members the activity digest aggregates. This is a SUBSET of
+ * `pyric`'s `SandboxEvent` — the listener-lifecycle / snapshot-delivery /
+ * session-boundary kinds carry no user-visible mutation, so the digest
+ * ignores them. The reducer accepts any object with a `kind` and skips
+ * the kinds it doesn't model, so a full `SandboxEvent[]` passes through
+ * cleanly (the extra kinds fall into the "unknown ⇒ skipped" branch).
+ */
+export type ActivityEvent = ActivityRequestEvent | ActivityWriteEvent | ActivityServiceMutationEvent;
+/**
+ * The widened input the reducer accepts: any `ActivityEvent`, plus a
+ * permissive escape for unmodelled `SandboxEvent` kinds carrying a
+ * string `kind` (skipped). Lets `sandbox.history()` flow in unfiltered.
+ */
+export type AnyActivityEvent = ActivityEvent | {
+    kind: string;
+    [k: string]: unknown;
+};
+/**
+ * A subscription: register a callback, get an unsubscribe.
+ * `sandbox.onEvent` matches this signature.
+ */
+export type ActivitySource = (cb: (event: AnyActivityEvent) => void) => () => void;
+//# sourceMappingURL=types.d.ts.map

package/dist/events/types.d.ts.map

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

package/dist/events/types.js

@@ -0,0 +1,21 @@
+/**
+ * The events/activity domain types. These are a local, structurally-
+ * compatible mirror of `pyric`'s unified `SandboxEvent` union (and its
+ * `EventProvenance`) — the `@pyric/ui` packages never import `pyric` so
+ * the headless layer stays decoupled from the sandbox impl (the same
+ * stance the sibling `traffic/` area takes with `RequestEvent`).
+ *
+ * `sandbox.onEvent` / `sandbox.history()` are assignable as an
+ * `ActivitySource` / `ActivityEvent[]` with zero adapter code: every
+ * field here is a subset (by name + shape) of the matching field on the
+ * sandbox type. A production audit feed satisfying the same shape works
+ * too.
+ *
+ * Unlike `traffic/` (which models only Firestore `request` events, one
+ * row per evaluated op), the events area aggregates the FULL stream —
+ * Firestore `request`/`write` plus the cross-service `service_mutation`
+ * envelope (auth / storage / rtdb) — into category bands. So the local
+ * types cover the union members the digest reads, not just one kind.
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/events/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/events/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG"}

package/dist/firestore/components/CollectionList.d.ts

@@ -0,0 +1,22 @@
+import type { ReactNode } from 'react';
+import type { CollectionReference } from 'pyric/firestore';
+export interface CollectionListProps {
+    collections: CollectionReference[];
+    isLoading?: boolean;
+    error?: Error;
+    /** Fired when a list item is clicked. Consumer wires navigation. */
+    onSelect?: (collection: CollectionReference) => void;
+    /** Optional empty-state node. Rendered when `collections.length`
+     *  is 0 and the list isn't loading. */
+    emptyState?: ReactNode;
+    className?: string;
+}
+/**
+ * Headless collection list. Takes a pre-fetched array of references
+ * (from `useCollectionList`) plus a select callback. Renders one
+ * row per collection with `data-pyric-collection-id` for styling
+ * and testing. The library does not own the data fetch — the hook
+ * does — so this component is a thin presentational layer.
+ */
+export declare function CollectionList({ collections, isLoading, error, onSelect, emptyState, className, }: CollectionListProps): import("react").JSX.Element;
+//# sourceMappingURL=CollectionList.d.ts.map

package/dist/firestore/components/CollectionList.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CollectionList.d.ts","sourceRoot":"","sources":["../../../src/firestore/components/CollectionList.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AACvC,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAE3D,MAAM,WAAW,mBAAmB;IAClC,WAAW,EAAE,mBAAmB,EAAE,CAAC;IACnC,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,KAAK,CAAC,EAAE,KAAK,CAAC;IACd,oEAAoE;IACpE,QAAQ,CAAC,EAAE,CAAC,UAAU,EAAE,mBAAmB,KAAK,IAAI,CAAC;IACrD;2CACuC;IACvC,UAAU,CAAC,EAAE,SAAS,CAAC;IACvB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,EAC7B,WAAW,EACX,SAAS,EACT,KAAK,EACL,QAAQ,EACR,UAAU,EACV,SAAS,GACV,EAAE,mBAAmB,+BAgDrB"}

package/dist/firestore/components/CollectionList.js

@@ -0,0 +1,21 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * Headless collection list. Takes a pre-fetched array of references
+ * (from `useCollectionList`) plus a select callback. Renders one
+ * row per collection with `data-pyric-collection-id` for styling
+ * and testing. The library does not own the data fetch — the hook
+ * does — so this component is a thin presentational layer.
+ */
+export function CollectionList({ collections, isLoading, error, onSelect, emptyState, className, }) {
+    if (error) {
+        return (_jsx("div", { className: className, "data-pyric-ui": "collection-list", "data-pyric-error": "", role: "alert", children: error.message }));
+    }
+    if (isLoading && collections.length === 0) {
+        return (_jsx("div", { className: className, "data-pyric-ui": "collection-list", "data-pyric-loading": "" }));
+    }
+    if (collections.length === 0) {
+        return (_jsx("div", { className: className, "data-pyric-ui": "collection-list", "data-pyric-empty": "", children: emptyState }));
+    }
+    return (_jsx("ul", { className: className, "data-pyric-ui": "collection-list", children: collections.map((coll) => (_jsx("li", { "data-pyric-collection-entry": true, "data-pyric-collection-id": coll.id, children: _jsx("button", { type: "button", onClick: () => onSelect?.(coll), "data-pyric-collection-select": true, children: coll.id }) }, coll.path))) }));
+}
+//# sourceMappingURL=CollectionList.js.map

package/dist/firestore/components/CollectionList.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CollectionList.js","sourceRoot":"","sources":["../../../src/firestore/components/CollectionList.tsx"],"names":[],"mappings":";AAeA;;;;;;GAMG;AACH,MAAM,UAAU,cAAc,CAAC,EAC7B,WAAW,EACX,SAAS,EACT,KAAK,EACL,QAAQ,EACR,UAAU,EACV,SAAS,GACW;IACpB,IAAI,KAAK,EAAE,CAAC;QACV,OAAO,CACL,cACE,SAAS,EAAE,SAAS,mBACN,iBAAiB,sBACd,EAAE,EACnB,IAAI,EAAC,OAAO,YAEX,KAAK,CAAC,OAAO,GACV,CACP,CAAC;IACJ,CAAC;IACD,IAAI,SAAS,IAAI,WAAW,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC1C,OAAO,CACL,cACE,SAAS,EAAE,SAAS,mBACN,iBAAiB,wBACZ,EAAE,GACrB,CACH,CAAC;IACJ,CAAC;IACD,IAAI,WAAW,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC7B,OAAO,CACL,cAAK,SAAS,EAAE,SAAS,mBAAgB,iBAAiB,sBAAkB,EAAE,YAC3E,UAAU,GACP,CACP,CAAC;IACJ,CAAC;IACD,OAAO,CACL,aAAI,SAAS,EAAE,SAAS,mBAAgB,iBAAiB,YACtD,WAAW,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CACzB,8EAG4B,IAAI,CAAC,EAAE,YAEjC,iBACE,IAAI,EAAC,QAAQ,EACb,OAAO,EAAE,GAAG,EAAE,CAAC,QAAQ,EAAE,CAAC,IAAI,CAAC,kDAG9B,IAAI,CAAC,EAAE,GACD,IAVJ,IAAI,CAAC,IAAI,CAWX,CACN,CAAC,GACC,CACN,CAAC;AACJ,CAAC"}

package/dist/firestore/components/DeleteWithConfirm.d.ts

@@ -0,0 +1,38 @@
+import { type ReactNode } from 'react';
+import type { CollectionReference, DocumentReference } from 'pyric/firestore';
+import { type RecursiveDeleteImpl } from '../hooks/useRecursiveDelete.js';
+export interface DeleteWithConfirmProps {
+    /** The doc / collection to delete. */
+    target: DocumentReference | CollectionReference;
+    /** Implementation that walks the tree + deletes. Consumer-supplied.
+     *  Sandbox-backed apps usually wire `pyric/sandbox` introspection;
+     *  production apps usually call a Cloud Function. */
+    impl: RecursiveDeleteImpl;
+    /** Confirm-dialog title. Defaults to a sensible derivation from
+     *  the target's path. */
+    title?: string;
+    /** Confirm-dialog body. */
+    body?: ReactNode;
+    /** Label on the destructive button. */
+    confirmLabel?: string;
+    /** Fired after the delete iterator finishes successfully. */
+    onDeleted?: () => void;
+    /** Optional render override for the trigger button. */
+    renderTrigger?: (props: {
+        onClick: () => void;
+        isRunning: boolean;
+        progress: number;
+    }) => ReactNode;
+    /** Class forwarded to the default trigger button. */
+    className?: string;
+}
+/**
+ * Composition that wires `useConfirm` + `useRecursiveDelete`. Requires
+ * a `<ConfirmProvider>` ancestor.
+ *
+ * The default trigger renders a plain `<button>` carrying the
+ * destructive intent (the consumer styles via `[data-pyric-destructive]`).
+ * Consumers wanting different chrome pass `renderTrigger`.
+ */
+export declare function DeleteWithConfirm({ target, impl, title, body, confirmLabel, onDeleted, renderTrigger, className, }: DeleteWithConfirmProps): import("react").JSX.Element;
+//# sourceMappingURL=DeleteWithConfirm.d.ts.map

package/dist/firestore/components/DeleteWithConfirm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DeleteWithConfirm.d.ts","sourceRoot":"","sources":["../../../src/firestore/components/DeleteWithConfirm.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AACvC,OAAO,KAAK,EACV,mBAAmB,EACnB,iBAAiB,EAClB,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EAEL,KAAK,mBAAmB,EACzB,MAAM,gCAAgC,CAAC;AAExC,MAAM,WAAW,sBAAsB;IACrC,sCAAsC;IACtC,MAAM,EAAE,iBAAiB,GAAG,mBAAmB,CAAC;IAChD;;yDAEqD;IACrD,IAAI,EAAE,mBAAmB,CAAC;IAC1B;6BACyB;IACzB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,2BAA2B;IAC3B,IAAI,CAAC,EAAE,SAAS,CAAC;IACjB,uCAAuC;IACvC,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,6DAA6D;IAC7D,SAAS,CAAC,EAAE,MAAM,IAAI,CAAC;IACvB,uDAAuD;IACvD,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE;QACtB,OAAO,EAAE,MAAM,IAAI,CAAC;QACpB,SAAS,EAAE,OAAO,CAAC;QACnB,QAAQ,EAAE,MAAM,CAAC;KAClB,KAAK,SAAS,CAAC;IAChB,qDAAqD;IACrD,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,EAChC,MAAM,EACN,IAAI,EACJ,KAAK,EACL,IAAI,EACJ,YAAuB,EACvB,SAAS,EACT,aAAa,EACb,SAAS,GACV,EAAE,sBAAsB,+BAiCxB"}

package/dist/firestore/components/DeleteWithConfirm.js

@@ -0,0 +1,33 @@
+import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+import { useConfirm } from '../../primitives/useConfirm.js';
+import { useRecursiveDelete, } from '../hooks/useRecursiveDelete.js';
+/**
+ * Composition that wires `useConfirm` + `useRecursiveDelete`. Requires
+ * a `<ConfirmProvider>` ancestor.
+ *
+ * The default trigger renders a plain `<button>` carrying the
+ * destructive intent (the consumer styles via `[data-pyric-destructive]`).
+ * Consumers wanting different chrome pass `renderTrigger`.
+ */
+export function DeleteWithConfirm({ target, impl, title, body, confirmLabel = 'Delete', onDeleted, renderTrigger, className, }) {
+    const confirm = useConfirm();
+    const { delete: runDelete, isRunning, progress, error } = useRecursiveDelete(impl);
+    const handleClick = async () => {
+        const ok = await confirm({
+            title: title ?? `Delete ${target.path}?`,
+            body,
+            destructive: true,
+            confirmLabel,
+        });
+        if (!ok)
+            return;
+        await runDelete(target);
+        if (!error)
+            onDeleted?.();
+    };
+    if (renderTrigger) {
+        return _jsx(_Fragment, { children: renderTrigger({ onClick: handleClick, isRunning, progress }) });
+    }
+    return (_jsx("button", { type: "button", onClick: handleClick, className: className, disabled: isRunning, "data-pyric-ui": "delete-with-confirm", "data-pyric-destructive": "", "data-pyric-running": isRunning ? '' : undefined, children: isRunning ? `Deleting… (${progress})` : confirmLabel }));
+}
+//# sourceMappingURL=DeleteWithConfirm.js.map

package/dist/firestore/components/DeleteWithConfirm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DeleteWithConfirm.js","sourceRoot":"","sources":["../../../src/firestore/components/DeleteWithConfirm.tsx"],"names":[],"mappings":";AAKA,OAAO,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAC;AAC5D,OAAO,EACL,kBAAkB,GAEnB,MAAM,gCAAgC,CAAC;AA4BxC;;;;;;;GAOG;AACH,MAAM,UAAU,iBAAiB,CAAC,EAChC,MAAM,EACN,IAAI,EACJ,KAAK,EACL,IAAI,EACJ,YAAY,GAAG,QAAQ,EACvB,SAAS,EACT,aAAa,EACb,SAAS,GACc;IACvB,MAAM,OAAO,GAAG,UAAU,EAAE,CAAC;IAC7B,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,SAAS,EAAE,QAAQ,EAAE,KAAK,EAAE,GAAG,kBAAkB,CAAC,IAAI,CAAC,CAAC;IAEnF,MAAM,WAAW,GAAG,KAAK,IAAI,EAAE;QAC7B,MAAM,EAAE,GAAG,MAAM,OAAO,CAAC;YACvB,KAAK,EAAE,KAAK,IAAI,UAAU,MAAM,CAAC,IAAI,GAAG;YACxC,IAAI;YACJ,WAAW,EAAE,IAAI;YACjB,YAAY;SACb,CAAC,CAAC;QACH,IAAI,CAAC,EAAE;YAAE,OAAO;QAChB,MAAM,SAAS,CAAC,MAAM,CAAC,CAAC;QACxB,IAAI,CAAC,KAAK;YAAE,SAAS,EAAE,EAAE,CAAC;IAC5B,CAAC,CAAC;IAEF,IAAI,aAAa,EAAE,CAAC;QAClB,OAAO,4BAAG,aAAa,CAAC,EAAE,OAAO,EAAE,WAAW,EAAE,SAAS,EAAE,QAAQ,EAAE,CAAC,GAAI,CAAC;IAC7E,CAAC;IAED,OAAO,CACL,iBACE,IAAI,EAAC,QAAQ,EACb,OAAO,EAAE,WAAW,EACpB,SAAS,EAAE,SAAS,EACpB,QAAQ,EAAE,SAAS,mBACL,qBAAqB,4BACZ,EAAE,wBACL,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,SAAS,YAE7C,SAAS,CAAC,CAAC,CAAC,cAAc,QAAQ,GAAG,CAAC,CAAC,CAAC,YAAY,GAC9C,CACV,CAAC;AACJ,CAAC"}

package/dist/firestore/components/DocumentEditor.d.ts

@@ -0,0 +1,47 @@
+import { type ReactNode } from 'react';
+import { type UseDocumentEditorResult } from '../hooks/useDocumentEditor.js';
+import type { FieldEditorRegistry } from '../fieldEditors/types.js';
+export interface DocumentEditorRootProps {
+    /** Initial document data. Built into the editor's tree on first
+     *  mount; later changes don't rebuild — call `editor.reset()` to
+     *  re-initialize from a fresh `initial`. */
+    initial?: Record<string, unknown>;
+    /** Override or extend the built-in field editors. */
+    fieldEditors?: FieldEditorRegistry;
+    /** Called on every state change with the latest editor state. The
+     *  parent typically watches `state.isValid` + `state.isDirty` to
+     *  enable/disable a Save button. */
+    onChange?: (state: UseDocumentEditorResult) => void;
+    children: ReactNode;
+    className?: string;
+}
+/**
+ * Wires the `useDocumentEditor` hook + field-editor registry into a
+ * React context so `<DocumentEditor.Fields>` and `<DocumentEditor.AddField>`
+ * can render the tree without prop drilling.
+ *
+ * Pattern: hook + compound component. Consumers wanting full control
+ * over the layout call `useDocumentEditor` directly and render their
+ * own tree; consumers wanting the default rendering use this.
+ */
+export declare function DocumentEditorRoot({ initial, fieldEditors, onChange, children, className, }: DocumentEditorRootProps): import("react").JSX.Element;
+/** Read access to the underlying editor state from inside a Root. */
+export declare function useDocumentEditorContext(): UseDocumentEditorResult;
+/**
+ * Renders the top-level fields of the document. For finer control,
+ * a consumer can call `useDocumentEditorContext()` and render the
+ * tree themselves.
+ */
+export declare function DocumentEditorFields(): import("react").JSX.Element;
+/**
+ * Compound root export. Consumers pattern-match via dot access:
+ *
+ *   <DocumentEditor.Root initial={data} onChange={…}>
+ *     <DocumentEditor.Fields />
+ *   </DocumentEditor.Root>
+ */
+export declare const DocumentEditor: {
+    Root: typeof DocumentEditorRoot;
+    Fields: typeof DocumentEditorFields;
+};
+//# sourceMappingURL=DocumentEditor.d.ts.map

package/dist/firestore/components/DocumentEditor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DocumentEditor.d.ts","sourceRoot":"","sources":["../../../src/firestore/components/DocumentEditor.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAgD,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AACrF,OAAO,EAAqB,KAAK,uBAAuB,EAAE,MAAM,+BAA+B,CAAC;AAEhG,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAsBpE,MAAM,WAAW,uBAAuB;IACtC;;gDAE4C;IAC5C,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAClC,qDAAqD;IACrD,YAAY,CAAC,EAAE,mBAAmB,CAAC;IACnC;;wCAEoC;IACpC,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,uBAAuB,KAAK,IAAI,CAAC;IACpD,QAAQ,EAAE,SAAS,CAAC;IACpB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAAC,EACjC,OAAO,EACP,YAAY,EACZ,QAAQ,EACR,QAAQ,EACR,SAAS,GACV,EAAE,uBAAuB,+BA6BzB;AAED,qEAAqE;AACrE,wBAAgB,wBAAwB,IAAI,uBAAuB,CAElE;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,gCAiBnC;AAkOD;;;;;;GAMG;AACH,eAAO,MAAM,cAAc;;;CAG1B,CAAC"}