@abloatai/ablo 0.11.1 → 0.11.2

package/dist/principal.js

@@ -1,49 +0,0 @@
-/**
- * Principal constructors — a thin typed façade over the raw
- * `SessionRef` / `AgentRef` shapes so call sites don't have to memorize
- * the discriminated-union tags.
- *
- * ```ts
- * import Ablo, { session } from '@abloatai/ablo';
- *
- * const ablo = Ablo({ schema, apiKey });
- * const participant = await ablo.participants.join({
- *   type: 'Matter',
- *   id: 'deal-1',
- * });
- * ```
- *
- * Browser-human flows use `session(...)`. Agent-spawn-agent flows use
- * `agent(...)`, but those rarely appear in customer code because the
- * participant layer handles attenuation.
- *
- * These are pure — no I/O, no hidden state. If the shape ever grows a
- * required field (say, a scope hint for the restricted key), the helper
- * is the one place to flag migrations.
- */
-/**
- * Build a `SessionRef` from the identifiers your auth system already
- * holds. Typical inputs: the Better Auth session id, the user id, and
- * the organization the session is scoped to.
- */
-export function session(params) {
-    return {
-        kind: 'session',
-        id: params.id,
-        userId: params.userId,
-        organizationId: params.organizationId,
-    };
-}
-/**
- * Build an `AgentRef` from an agent id + the capability token that
- * authenticates it. Rare in application code — the common path is
- * `participant.join(child)` where the parent's token is attenuated
- * automatically.
- */
-export function agent(params) {
-    return {
-        kind: 'agent',
-        id: params.id,
-        capabilityToken: params.capabilityToken,
-    };
-}

package/dist/react/SyncGroupProvider.d.ts

@@ -1,19 +0,0 @@
-import { type ReactNode } from 'react';
-export interface SyncGroupProviderProps {
-    /** The sync-group identifier — e.g., `matter:abc-123`, `deck:xyz`. */
-    id: string;
-    children: ReactNode;
-}
-export declare function SyncGroupProvider({ id, children }: SyncGroupProviderProps): import("react").JSX.Element;
-/**
- * Returns the ID of the nearest `<SyncGroupProvider>`. Throws if
- * called outside one — sync-group awareness is mandatory by design,
- * so the error points the consumer at the provider instead of
- * returning undefined and letting downstream code silently miss scope.
- *
- * If a component legitimately renders both inside and outside a
- * group, structure the tree so the hook is only called on the
- * inside path (e.g., split into two components). Silent nulls are
- * never the right answer.
- */
-export declare function useSyncGroup(): string;

package/dist/react/SyncGroupProvider.js

@@ -1,44 +0,0 @@
-'use client';
-import { jsx as _jsx } from "react/jsx-runtime";
-import { createContext, useContext, useMemo } from 'react';
-import { AbloValidationError } from '../errors.js';
-/**
- * Narrow context for a per-entity sync-group scope. Maps directly onto
- * Liveblocks' `<RoomProvider id="...">`: wrap a subtree, and any hooks
- * inside can read `useSyncGroup()` to discover "which entity am I
- * scoped to?" without threading the ID through props.
- *
- * Typical IDs follow the multiplayer sync-group convention: `matter:<id>`,
- * `deck:<id>`, `project:<id>`. The ID is an opaque string — the
- * provider doesn't parse it.
- *
- * v0.3.0 scope: this is a thin passthrough. Future versions will
- * scope `useQuery` / `useOne` results to the group automatically.
- */
-const SyncGroupContext = createContext(null);
-export function SyncGroupProvider({ id, children }) {
-    // Stabilize the context value so consumers memoized on it don't
-    // re-render when the provider re-renders for unrelated reasons.
-    const value = useMemo(() => id, [id]);
-    return _jsx(SyncGroupContext.Provider, { value: value, children: children });
-}
-/**
- * Returns the ID of the nearest `<SyncGroupProvider>`. Throws if
- * called outside one — sync-group awareness is mandatory by design,
- * so the error points the consumer at the provider instead of
- * returning undefined and letting downstream code silently miss scope.
- *
- * If a component legitimately renders both inside and outside a
- * group, structure the tree so the hook is only called on the
- * inside path (e.g., split into two components). Silent nulls are
- * never the right answer.
- */
-export function useSyncGroup() {
-    const id = useContext(SyncGroupContext);
-    if (!id) {
-        throw new AbloValidationError('useSyncGroup: no <SyncGroupProvider> mounted above this component. ' +
-            'Wrap your tree with <SyncGroupProvider id="matter:..."> from ' +
-            '@abloatai/ablo/react.', { code: 'no_sync_group_provider' });
-    }
-    return id;
-}

package/dist/react/useClaim.d.ts

@@ -1,29 +0,0 @@
-import type { ResolveClaims } from '../types/global.js';
-/**
- * Named-claim invoker, typed via `ResolveClaims[ClaimName]`.
- *
- * The consumer declares their claim vocabulary in the global:
- *
- * ```ts
- * declare module '@abloatai/ablo' {
- *   interface Register {
- *     Claims: {
- *       editLayer: { slideId: string; layerId: string };
- *       generateWithAI: { entityId: string; tool: string };
- *     };
- *   }
- * }
- * ```
- *
- * Then `useClaim('editLayer')` returns a function whose sole argument
- * is the `editLayer` claim shape — no runtime checks, purely compile-
- * time narrowing.
- *
- * The SDK doesn't own what happens next: the `beginClaim` function on
- * the React context (supplied via `SyncProvider`) is where the claim
- * claim turns into a network effect. A Node-backed consumer wires it
- * through `SyncAgent.beginClaim`; a browser-backed consumer may
- * broadcast it through their own WebSocket. This hook is pure sugar
- * that adds the typed name + claim narrowing.
- */
-export declare function useClaim<Name extends keyof ResolveClaims & string>(claimName: Name): (claim: ResolveClaims[Name]) => unknown;

package/dist/react/useClaim.js

@@ -1,42 +0,0 @@
-'use client';
-import { useCallback } from 'react';
-import { useSyncContext } from './context.js';
-import { AbloValidationError } from '../errors.js';
-/**
- * Named-claim invoker, typed via `ResolveClaims[ClaimName]`.
- *
- * The consumer declares their claim vocabulary in the global:
- *
- * ```ts
- * declare module '@abloatai/ablo' {
- *   interface Register {
- *     Claims: {
- *       editLayer: { slideId: string; layerId: string };
- *       generateWithAI: { entityId: string; tool: string };
- *     };
- *   }
- * }
- * ```
- *
- * Then `useClaim('editLayer')` returns a function whose sole argument
- * is the `editLayer` claim shape — no runtime checks, purely compile-
- * time narrowing.
- *
- * The SDK doesn't own what happens next: the `beginClaim` function on
- * the React context (supplied via `SyncProvider`) is where the claim
- * claim turns into a network effect. A Node-backed consumer wires it
- * through `SyncAgent.beginClaim`; a browser-backed consumer may
- * broadcast it through their own WebSocket. This hook is pure sugar
- * that adds the typed name + claim narrowing.
- */
-export function useClaim(claimName) {
-    const { beginClaim } = useSyncContext();
-    return useCallback((claim) => {
-        if (!beginClaim) {
-            throw new AbloValidationError(`useClaim: no \`beginClaim\` wired into SyncProvider. Pass ` +
-                `a \`beginClaim\` prop (typically bound to your transport) ` +
-                `to enable claim invocations.`, { code: 'claim_not_wired' });
-        }
-        return beginClaim(claimName, claim);
-    }, [beginClaim, claimName]);
-}

package/dist/react/usePresence.d.ts

@@ -1,32 +0,0 @@
-import type { ResolvePresence } from '../types/global.js';
-/**
- * Read the consumer-supplied presence state with `ResolvePresence`d
- * typing — the shape the consumer declared in
- * `declare module '@abloatai/ablo' { interface Register { Presence: ... } }`.
- *
- * The SDK doesn't own a presence wire format. Consumers plug whatever
- * backs their cursors, status, or activity (a MobX store, a custom
- * WebSocket channel, `SyncAgent` in Node, a Zustand slice) via the
- * `presence` prop on `SyncProvider`. This hook returns it typed.
- *
- * ```ts
- * // apps/your-app/src/ablo-sync.d.ts
- * declare module '@abloatai/ablo' {
- *   interface Register {
- *     Presence: { cursor: { x: number; y: number } | null; status: 'away' | 'online' };
- *   }
- * }
- *
- * // consumer's <SyncProvider> wiring
- * <SyncProvider store={store} organizationId={orgId} presence={presenceStore}>
- *
- * // any component
- * const presence = usePresence();
- * presence?.cursor?.x; // fully typed
- * ```
- *
- * Returns `undefined` when no provider-level presence source is wired —
- * consumers can narrow with a guard or configure a default in their
- * provider.
- */
-export declare function usePresence(): ResolvePresence | undefined;

package/dist/react/usePresence.js

@@ -1,41 +0,0 @@
-'use client';
-import { useSyncContext } from './context.js';
-/**
- * Read the consumer-supplied presence state with `ResolvePresence`d
- * typing — the shape the consumer declared in
- * `declare module '@abloatai/ablo' { interface Register { Presence: ... } }`.
- *
- * The SDK doesn't own a presence wire format. Consumers plug whatever
- * backs their cursors, status, or activity (a MobX store, a custom
- * WebSocket channel, `SyncAgent` in Node, a Zustand slice) via the
- * `presence` prop on `SyncProvider`. This hook returns it typed.
- *
- * ```ts
- * // apps/your-app/src/ablo-sync.d.ts
- * declare module '@abloatai/ablo' {
- *   interface Register {
- *     Presence: { cursor: { x: number; y: number } | null; status: 'away' | 'online' };
- *   }
- * }
- *
- * // consumer's <SyncProvider> wiring
- * <SyncProvider store={store} organizationId={orgId} presence={presenceStore}>
- *
- * // any component
- * const presence = usePresence();
- * presence?.cursor?.x; // fully typed
- * ```
- *
- * Returns `undefined` when no provider-level presence source is wired —
- * consumers can narrow with a guard or configure a default in their
- * provider.
- */
-export function usePresence() {
-    const ctx = useSyncContext();
-    // The runtime value is whatever the consumer passed to `SyncProvider`.
-    // The type assertion reflects the consumer's declared global, which
-    // the hook can't verify at runtime — but the consumer controls both
-    // ends (the registration and the provider prop) so this is a
-    // single-source-of-truth contract, not blind trust.
-    return ctx.presence;
-}