@jini-ai/admin 0.3.10 → 0.4.1

package/dist/media/rules.d.ts

@@ -0,0 +1,86 @@
+import type { MediaAsset, MediaContentTabId, MediaTabId, MediaQuery, MediaMetadataPatch } from './models.js';
+/** Falls back to "all" for an absent or unrecognized ?tab= value — don't trust a raw
+ * query value: a stale link or a typo must not blank the panel. */
+export declare function resolveActiveTab({ tabId }: {
+    tabId?: string | null | undefined;
+}, _optional?: Record<string, never>): MediaTabId;
+/** Prefix matching on image/ and video/ rather than an enumerated list of the sniffer's
+ * current outputs: the server's sniffer allowlist can gain a format without this file
+ * having to learn about it, and a prefix cannot mis-sort a type it has never seen.
+ * application/octet-stream and null belong in All. SVG appears in Images, but its
+ * byte-serving route must force download as a stored-XSS defusal. */
+export declare function filterMediaByTab({ media, tab }: {
+    media: readonly MediaAsset[];
+    tab: MediaContentTabId;
+}, _optional?: Record<string, never>): readonly MediaAsset[];
+export declare function queryMedia({ media, query }: {
+    media: readonly MediaAsset[];
+    query: MediaQuery;
+}, _optional?: Record<string, never>): readonly MediaAsset[];
+/** item MUST be the same snapshot draft was seeded from, frozen for the caller's whole
+ * edit session — never a live value that can advance independently of draft. If item
+ * moves out from under a frozen draft, an untouched field whose server value changed
+ * in the interim reads as "changed" and silently reverts the other operator's change. */
+export declare function diffMediaMetadata({ item, draft }: {
+    item: MediaAsset;
+    draft: MediaMetadataPatch;
+}, _optional?: Record<string, never>): MediaMetadataPatch;
+export declare function acceptsMedia({ item, accept }: {
+    item: Pick<MediaAsset, 'contentType'>;
+    accept: readonly string[];
+}, _optional?: Record<string, never>): boolean;
+export declare function safeMediaUrl({ url }: {
+    url: string;
+}, _optional?: Record<string, never>): string | undefined;
+/** A callable optional port, plus the legacy explicit-disable flag, is required. */
+export declare function canReplaceMedia({ api }: {
+    api: import('./ports.js').MediaApiPort;
+}, _optional?: Record<string, never>): boolean;
+export declare function canRestoreMedia({ api }: {
+    api: import('./ports.js').MediaApiPort;
+}, _optional?: Record<string, never>): boolean;
+/** Prefer the transport's retryability decision. Older transports only expose HTTP
+ * status in their message; network failures and temporary server failures recover too.
+ * Authorization/validation failures must never produce an automatic request loop. */
+export declare function isRetryableMediaError({ error }: {
+    error: unknown;
+}, _optional?: Record<string, never>): boolean;
+/** Blank means native size; invalid values reach the server's positive-integer validator. */
+export declare function parseOptionalPixelSize({ value }: {
+    value: string;
+}, _optional?: Record<string, never>): number | null;
+/** 1024-based to agree with upload limits. Whole B/KB, one decimal MB/GB distinguishes
+ * similarly sized clips; locale controls the decimal separator, never a hardcoded dot. */
+export declare function formatByteSize({ bytes }: {
+    bytes: number;
+}, { locale }?: {
+    locale?: string;
+}): string;
+/** Full-library counts, independent of search/order/type selection; Providers has no count. */
+export declare function countMediaTabs({ media }: {
+    media: readonly MediaAsset[];
+}, _optional?: Record<string, never>): {
+    all: number;
+    images: number;
+    videos: number;
+};
+/** Readable slug markers survive title/hash changes. Escape attribute delimiters even
+ * though real hosts validate slugs; a test or third-party adapter must not inject markup. */
+export declare function mediaEmbedSnippet({ slug }: {
+    slug?: string | undefined;
+}, _optional?: Record<string, never>): string | null;
+/** Legacy row handles derive from stable IDs across the ENTIRE visible list. Per-card
+ * slugification cannot resolve collisions: duplicate handles silently make page.click/fill
+ * target the first DOM match. Search suffixes, because [x, x-2, X] can collide again.
+ * This media-local shape mirrors the agent runtime's canonical list-handle contract without
+ * adding a package dependency in a source-only change. */
+export declare function mediaRowHandles({ media }: {
+    media: readonly Pick<MediaAsset, 'id'>[];
+}, _optional?: Record<string, never>): readonly string[];
+/** A calendar date in UTC, so cards do not shift an upload to yesterday across host timezones. */
+export declare function formatUploadDate({ createdAt }: {
+    createdAt: string;
+}, { locale }?: {
+    locale?: string;
+}): string | null;
+//# sourceMappingURL=rules.d.ts.map

package/dist/media/rules.js

@@ -0,0 +1,134 @@
+/** Falls back to "all" for an absent or unrecognized ?tab= value — don't trust a raw
+ * query value: a stale link or a typo must not blank the panel. */
+export function resolveActiveTab({ tabId }, _optional = {}) {
+    return tabId === 'images' || tabId === 'videos' || tabId === 'external-providers' ? tabId : 'all';
+}
+/** Prefix matching on image/ and video/ rather than an enumerated list of the sniffer's
+ * current outputs: the server's sniffer allowlist can gain a format without this file
+ * having to learn about it, and a prefix cannot mis-sort a type it has never seen.
+ * application/octet-stream and null belong in All. SVG appears in Images, but its
+ * byte-serving route must force download as a stored-XSS defusal. */
+export function filterMediaByTab({ media, tab }, _optional = {}) {
+    if (tab === 'images')
+        return media.filter((item) => item.contentType?.startsWith('image/'));
+    if (tab === 'videos')
+        return media.filter((item) => item.contentType?.startsWith('video/'));
+    return media;
+}
+export function queryMedia({ media, query }, _optional = {}) {
+    const search = query.search?.trim().toLocaleLowerCase() ?? '';
+    const filtered = filterMediaByTab({ media, tab: query.filter ?? 'all' }).filter((item) => (!query.status || item.status === query.status) &&
+        (!search || `${item.title} ${item.alt}`.toLocaleLowerCase().includes(search)));
+    // Newest-first with id descending tiebreak, so same-tick batch uploads have deterministic order.
+    // Alphabetical is case-insensitive A–Z, with id ascending on a title collision.
+    return [...filtered].sort((a, b) => query.orderBy === 'alphabetical'
+        ? a.title.trim().toLocaleLowerCase().localeCompare(b.title.trim().toLocaleLowerCase()) ||
+            a.id.localeCompare(b.id)
+        : b.createdAt.localeCompare(a.createdAt) || b.id.localeCompare(a.id));
+}
+/** item MUST be the same snapshot draft was seeded from, frozen for the caller's whole
+ * edit session — never a live value that can advance independently of draft. If item
+ * moves out from under a frozen draft, an untouched field whose server value changed
+ * in the interim reads as "changed" and silently reverts the other operator's change. */
+export function diffMediaMetadata({ item, draft }, _optional = {}) {
+    const patch = {};
+    for (const key of ['title', 'slug', 'alt', 'caption', 'credit', 'width', 'height', 'cssClass', 'htmlAttributes'])
+        if (draft[key] !== undefined && draft[key] !== item[key])
+            patch[key] = draft[key];
+    return patch;
+}
+export function acceptsMedia({ item, accept }, _optional = {}) {
+    if (accept.length === 0 || accept.includes('*/*'))
+        return true;
+    return (item.contentType !== null &&
+        accept.some((type) => type === item.contentType ||
+            (type.endsWith('/*') && item.contentType.startsWith(type.slice(0, -1)))));
+}
+export function safeMediaUrl({ url }, _optional = {}) {
+    // Fail closed on javascript:, data:, scheme-relative and backslash URLs. The host owns
+    // same-origin authentication and attachment headers for HTML/SVG originals.
+    if (url.startsWith('/') && !url.startsWith('//') && !url.includes('\\'))
+        return url;
+    try {
+        const parsed = new URL(url);
+        if (parsed.protocol === 'https:' || parsed.protocol === 'http:' || parsed.protocol === 'blob:')
+            return url;
+    }
+    catch {
+        /* invalid URL */
+    }
+    return undefined;
+}
+/** A callable optional port, plus the legacy explicit-disable flag, is required. */
+export function canReplaceMedia({ api }, _optional = {}) {
+    return typeof api.replace === 'function' && api.replaceSupported !== false;
+}
+export function canRestoreMedia({ api }, _optional = {}) {
+    return typeof api.restore === 'function' && api.restoreSupported !== false;
+}
+/** Prefer the transport's retryability decision. Older transports only expose HTTP
+ * status in their message; network failures and temporary server failures recover too.
+ * Authorization/validation failures must never produce an automatic request loop. */
+export function isRetryableMediaError({ error }, _optional = {}) {
+    if (!error || typeof error !== 'object')
+        return false;
+    const failure = error;
+    if (typeof failure.retryable === 'boolean')
+        return failure.retryable;
+    const status = failure.status ?? failure.statusCode ?? Number(failure.message?.match(/HTTP\s+(\d{3})/i)?.[1]);
+    return status === 408 || status === 429 || (status >= 500 && status <= 599) || error instanceof TypeError;
+}
+/** Blank means native size; invalid values reach the server's positive-integer validator. */
+export function parseOptionalPixelSize({ value }, _optional = {}) {
+    return value.trim() === '' ? null : Number(value);
+}
+/** 1024-based to agree with upload limits. Whole B/KB, one decimal MB/GB distinguishes
+ * similarly sized clips; locale controls the decimal separator, never a hardcoded dot. */
+export function formatByteSize({ bytes }, { locale = 'en-US' } = {}) {
+    if (bytes < 1024)
+        return `${Math.round(bytes)} B`;
+    const kb = bytes / 1024;
+    if (kb < 1024)
+        return `${Math.round(kb)} KB`;
+    const decimal = new Intl.NumberFormat(locale, { minimumFractionDigits: 1, maximumFractionDigits: 1 });
+    const mb = kb / 1024;
+    return mb < 1024 ? `${decimal.format(mb)} MB` : `${decimal.format(mb / 1024)} GB`;
+}
+/** Full-library counts, independent of search/order/type selection; Providers has no count. */
+export function countMediaTabs({ media }, _optional = {}) {
+    return { all: media.length, images: filterMediaByTab({ media, tab: 'images' }).length,
+        videos: filterMediaByTab({ media, tab: 'videos' }).length };
+}
+/** Readable slug markers survive title/hash changes. Escape attribute delimiters even
+ * though real hosts validate slugs; a test or third-party adapter must not inject markup. */
+export function mediaEmbedSnippet({ slug }, _optional = {}) {
+    if (!slug)
+        return null;
+    const config = JSON.stringify({ type: 'media', slug }).replace(/&/g, '&amp;').replace(/'/g, '&#39;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+    return `<div data-embed-config='${config}'></div>`;
+}
+/** Legacy row handles derive from stable IDs across the ENTIRE visible list. Per-card
+ * slugification cannot resolve collisions: duplicate handles silently make page.click/fill
+ * target the first DOM match. Search suffixes, because [x, x-2, X] can collide again.
+ * This media-local shape mirrors the agent runtime's canonical list-handle contract without
+ * adding a package dependency in a source-only change. */
+export function mediaRowHandles({ media }, _optional = {}) {
+    const used = new Set();
+    return media.map((item, index) => {
+        const slug = item.id.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '');
+        const preferred = `media-item-${slug || index + 1}`;
+        let handle = preferred, suffix = 2;
+        while (used.has(handle))
+            handle = `${preferred}-${suffix++}`;
+        used.add(handle);
+        return handle;
+    });
+}
+/** A calendar date in UTC, so cards do not shift an upload to yesterday across host timezones. */
+export function formatUploadDate({ createdAt }, { locale = 'en-US' } = {}) {
+    const date = new Date(createdAt);
+    if (!Number.isFinite(date.getTime()))
+        return null;
+    return new Intl.DateTimeFormat(locale, { month: 'short', day: 'numeric', year: 'numeric', timeZone: 'UTC' }).format(date);
+}
+//# sourceMappingURL=rules.js.map

package/dist/media/styles.d.ts

@@ -0,0 +1,4 @@
+/** Scoped feature presentation travels with compiled JS. It also overrides host dialog
+ * CSS that can accidentally display a closed dialog or shrink a large media preview. */
+export declare const mediaStyles = "";
+//# sourceMappingURL=styles.d.ts.map

package/dist/media/styles.js

@@ -0,0 +1,5 @@
+/** Scoped feature presentation travels with compiled JS. It also overrides host dialog
+ * CSS that can accidentally display a closed dialog or shrink a large media preview. */
+// Host CSS now supplies presentation and the closed-dialog safeguards on jini- classes.
+export const mediaStyles = '';
+//# sourceMappingURL=styles.js.map

package/dist/playground/adapters/http.d.ts

@@ -0,0 +1,8 @@
+/** The source registers a local portal node. It has no server route to adapt.
+ * Serializing that node or inventing a backend would change the whiteboard contract. */
+export declare const playgroundHttpSupport: Readonly<{
+    supported: false;
+    routes: readonly string[];
+    reason: "Playground is a browser render-target handshake with no HTTP routes.";
+}>;
+//# sourceMappingURL=http.d.ts.map

package/dist/playground/adapters/http.js

@@ -0,0 +1,4 @@
+/** The source registers a local portal node. It has no server route to adapt.
+ * Serializing that node or inventing a backend would change the whiteboard contract. */
+export const playgroundHttpSupport = Object.freeze({ supported: false, routes: Object.freeze([]), reason: 'Playground is a browser render-target handshake with no HTTP routes.' });
+//# sourceMappingURL=http.js.map

package/dist/playground/adapters/memory.d.ts

@@ -0,0 +1,10 @@
+import type { PlaygroundRenderTargetPort } from '../../contracts/playground-render-target.js';
+/** Instance-local browser bus as well as a headless fake; no global module singleton. */
+export declare function createMemoryPlaygroundTargets(_required: Record<string, never>, { onListenerError }?: {
+    onListenerError?: (required: {
+        error: unknown;
+    }, optional?: Record<string, never>) => void;
+}): PlaygroundRenderTargetPort & {
+    dispose(required?: Record<string, never>, optional?: Record<string, never>): void;
+};
+//# sourceMappingURL=memory.d.ts.map

package/dist/playground/adapters/memory.js

@@ -0,0 +1,30 @@
+/** Instance-local browser bus as well as a headless fake; no global module singleton. */
+export function createMemoryPlaygroundTargets(_required, { onListenerError } = {}) {
+    let snapshot = Object.freeze({ target: null }), owner = null, disposed = false;
+    const listeners = new Set();
+    function publish(target) {
+        // No-op on unchanged value: ref replay cannot produce a notification storm.
+        if (snapshot.target === target)
+            return;
+        snapshot = Object.freeze({ target });
+        for (const listener of [...listeners]) {
+            try {
+                listener();
+            }
+            catch (error) {
+                onListenerError?.({ error });
+            }
+        }
+    }
+    return {
+        getSnapshot: (_required = {}, _optional = {}) => snapshot,
+        subscribe({ listener }, _optional = {}) { if (!disposed)
+            listeners.add(listener); return () => listeners.delete(listener); },
+        register({ target }, _optional = {}) { if (disposed)
+            throw new Error('Playground target scope disposed'); const ticket = {}; owner = ticket; publish(target); return { release(_required = {}, _optional = {}) { if (owner !== ticket)
+                return; owner = null; publish(null); } }; },
+        dispose(_required = {}, _optional = {}) { if (disposed)
+            return; disposed = true; owner = null; publish(null); listeners.clear(); },
+    };
+}
+//# sourceMappingURL=memory.js.map

package/dist/playground/conformance/playground-api.conformance.d.ts

@@ -0,0 +1,6 @@
+import type { PlaygroundRenderTargetPort } from '../../contracts/playground-render-target.js';
+/** Run with an isolated bus; this temporarily registers and releases test targets. */
+export declare function runPlaygroundApiConformance({ targets }: {
+    targets: PlaygroundRenderTargetPort;
+}, _optional?: {}): readonly string[];
+//# sourceMappingURL=playground-api.conformance.d.ts.map

package/dist/playground/conformance/playground-api.conformance.js

@@ -0,0 +1,37 @@
+/** Run with an isolated bus; this temporarily registers and releases test targets. */
+export function runPlaygroundApiConformance({ targets }, _optional = {}) {
+    const checks = [];
+    const assert = (ok, name) => { if (!ok)
+        throw new Error(`Playground conformance: ${name}`); checks.push(name); };
+    const a = {}, b = {};
+    let count = 0;
+    const stop = targets.subscribe({ listener: () => count++ });
+    const first = targets.register({ target: a });
+    let second;
+    try {
+        assert(targets.getSnapshot().target === a, 'published target is readable');
+        const snapshot = targets.getSnapshot();
+        assert(snapshot === targets.getSnapshot(), 'snapshot identity is cached');
+        const same = targets.register({ target: a });
+        assert(count === 1, 'unchanged node does not notify');
+        first.release({});
+        assert(targets.getSnapshot().target === a, 'stale publisher cannot clear current target');
+        second = targets.register({ target: b });
+        assert(snapshot.target === a, 'prior snapshots do not mutate');
+        same.release({});
+        assert(targets.getSnapshot().target === b, 'release cannot clear a newer node');
+        second.release({});
+        assert(targets.getSnapshot().target === null && count === 3, 'detach publishes inline fallback');
+        stop();
+        const last = targets.register({ target: a });
+        last.release({});
+        assert(count === 3, 'unsubscribe stops notifications');
+        return Object.freeze(checks);
+    }
+    finally {
+        first.release({});
+        second?.release({});
+        stop();
+    }
+}
+//# sourceMappingURL=playground-api.conformance.js.map

package/dist/playground/controllers/playground.controller.d.ts

@@ -0,0 +1,16 @@
+import type { PlaygroundRenderTargetPort } from '../../contracts/playground-render-target.js';
+import type { PlaygroundState } from '../models.js';
+export declare function createPlaygroundController({ targets, permissions }: {
+    targets: PlaygroundRenderTargetPort;
+    permissions?: readonly string[];
+}, _optional?: {}): {
+    getSnapshot: () => Readonly<PlaygroundState>;
+    subscribe: ({ listener }: {
+        listener: () => void;
+    }) => () => void;
+    attach({ target }: {
+        target: object | null;
+    }, _optional?: {}): void;
+    dispose(_required?: Record<string, never>, _optional?: {}): void;
+};
+//# sourceMappingURL=playground.controller.d.ts.map

package/dist/playground/controllers/playground.controller.js

@@ -0,0 +1,21 @@
+import { createControllerStore } from '../../core/module/controller-store.js';
+import { canMountPlayground } from '../rules.js';
+export function createPlaygroundController({ targets, permissions = [] }, _optional = {}) {
+    const store = createControllerStore({ initial: { attached: false } });
+    let node = null, lease = null;
+    function detach() { lease?.release({}); lease = null; node = null; store.set({ patch: { attached: false } }); }
+    return { getSnapshot: store.getSnapshot, subscribe: store.subscribe,
+        attach({ target }, _optional = {}) {
+            if (store.signal.aborted || !canMountPlayground({ permissions }) || target === node)
+                return;
+            detach();
+            if (target) {
+                lease = targets.register({ target });
+                node = target;
+                store.set({ patch: { attached: true } });
+            }
+        },
+        dispose(_required = {}, _optional = {}) { detach(); store.dispose(); },
+    };
+}
+//# sourceMappingURL=playground.controller.js.map

package/dist/playground/index.d.ts

@@ -0,0 +1,7 @@
+export { playgroundModule } from './playground.module.js';
+export { createPlaygroundController } from './controllers/playground.controller.js';
+export { canMountPlayground } from './rules.js';
+export { playgroundMessagesEn } from './messages.en.js';
+export type { PlaygroundState } from './models.js';
+export type { PlaygroundPorts } from './ports.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/playground/index.js

@@ -0,0 +1,5 @@
+export { playgroundModule } from './playground.module.js';
+export { createPlaygroundController } from './controllers/playground.controller.js';
+export { canMountPlayground } from './rules.js';
+export { playgroundMessagesEn } from './messages.en.js';
+//# sourceMappingURL=index.js.map

package/dist/playground/messages.en.d.ts

@@ -0,0 +1,9 @@
+export declare const playgroundMessagesEn: Readonly<{
+    title: "Playground";
+    studio: "Studio";
+    canvas: "Canvas";
+    description: "Ask the assistant to build anything — try “Show a pie chart of my data.”";
+    empty: "Nothing drawn yet — ask the assistant.";
+    denied: "Permission denied";
+}>;
+//# sourceMappingURL=messages.en.d.ts.map

package/dist/playground/messages.en.js

@@ -0,0 +1,2 @@
+export const playgroundMessagesEn = Object.freeze({ title: 'Playground', studio: 'Studio', canvas: 'Canvas', description: 'Ask the assistant to build anything — try “Show a pie chart of my data.”', empty: 'Nothing drawn yet — ask the assistant.', denied: 'Permission denied' });
+//# sourceMappingURL=messages.en.js.map

package/dist/playground/models.d.ts

@@ -0,0 +1,4 @@
+export interface PlaygroundState {
+    readonly attached: boolean;
+}
+//# sourceMappingURL=models.d.ts.map

package/dist/playground/models.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=models.js.map

package/dist/playground/playground.module.d.ts

@@ -0,0 +1,31 @@
+export declare const playgroundModule: {
+    readonly id: "playground";
+    readonly requires: {
+        readonly playgroundTargets: import("../core/module/token.js").AdminPortToken<import("../contracts/playground-render-target.js").PlaygroundRenderTargetPort, "admin.playground.render-target">;
+    };
+    readonly messages: Readonly<{
+        title: "Playground";
+        studio: "Studio";
+        canvas: "Canvas";
+        description: "Ask the assistant to build anything — try “Show a pie chart of my data.”";
+        empty: "Nothing drawn yet — ask the assistant.";
+        denied: "Permission denied";
+    }>;
+    readonly pages: {
+        readonly playground: {
+            readonly path: "/playground";
+            readonly label: "Playground";
+            readonly permissions: readonly ["playground.read"];
+            readonly nav: {
+                readonly group: "studio";
+                readonly icon: "canvas";
+            };
+            readonly tabs: {
+                readonly canvas: {
+                    readonly label: "Canvas";
+                };
+            };
+        };
+    };
+};
+//# sourceMappingURL=playground.module.d.ts.map

package/dist/playground/playground.module.js

@@ -0,0 +1,5 @@
+import { defineAdminModule } from '../core/module/index.js';
+import { playgroundRenderTargetToken } from '../contracts/playground-render-target.js';
+import { playgroundMessagesEn } from './messages.en.js';
+export const playgroundModule = defineAdminModule({ id: 'playground', requires: { playgroundTargets: playgroundRenderTargetToken }, messages: playgroundMessagesEn, pages: { playground: { path: '/playground', label: playgroundMessagesEn.title, permissions: ['playground.read'], nav: { group: 'studio', icon: 'canvas' }, tabs: { canvas: { label: playgroundMessagesEn.canvas } } } } });
+//# sourceMappingURL=playground.module.js.map

package/dist/playground/ports.d.ts

@@ -0,0 +1,5 @@
+import type { PlaygroundRenderTargetPort } from '../contracts/playground-render-target.js';
+export interface PlaygroundPorts {
+    readonly playgroundTargets: PlaygroundRenderTargetPort;
+}
+//# sourceMappingURL=ports.d.ts.map

package/dist/playground/ports.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ports.js.map

package/dist/playground/react/components/Canvas.d.ts

@@ -0,0 +1,3 @@
+import type { TabViewProps } from '../../../react/bind-react.js';
+export declare function Canvas(props: TabViewProps, _optional?: {}): import("react").JSX.Element;
+//# sourceMappingURL=Canvas.d.ts.map

package/dist/playground/react/components/Canvas.js

@@ -0,0 +1,9 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Notice } from '@jini-ai/ui-kit/react';
+import { useCanvas } from '../hooks/Canvas.hooks.js';
+import { playgroundMessagesEn as m } from '../../messages.en.js';
+export function Canvas(props, _optional = {}) {
+    const vm = useCanvas(props);
+    return vm.denied ? _jsx(Notice, { tone: "danger", children: m.denied }) : _jsxs("section", { children: [_jsx("h2", { children: m.canvas }), _jsx("style", { children: vm.styles }), _jsx("div", { "data-jini-part": "playground.canvas", className: "jini-playground-canvas", ref: vm.registerCanvas }), _jsx("p", { "data-jini-part": "playground.empty", className: "jini-playground-empty", children: m.empty })] });
+}
+//# sourceMappingURL=Canvas.js.map

package/dist/playground/react/hooks/Canvas.hooks.d.ts

@@ -0,0 +1,7 @@
+import type { TabViewProps } from '../../../react/bind-react.js';
+export declare function useCanvas({ permissions }: TabViewProps, _optional?: {}): {
+    denied: boolean;
+    registerCanvas: (node: HTMLDivElement | null) => void | undefined;
+    styles: string;
+};
+//# sourceMappingURL=Canvas.hooks.d.ts.map

package/dist/playground/react/hooks/Canvas.hooks.js

@@ -0,0 +1,18 @@
+import { useCallback } from 'react';
+import { useController } from '../../../react/use-controller.js';
+import { createPlaygroundController } from '../../controllers/playground.controller.js';
+import { canMountPlayground } from '../../rules.js';
+import { usePlaygroundPorts } from './PlaygroundPorts.hooks.js';
+export function useCanvas({ permissions = [] }, _optional = {}) {
+    const { playgroundTargets } = usePlaygroundPorts({});
+    const key = permissions.join('\0');
+    const { controller } = useController({ create: () => createPlaygroundController({ targets: playgroundTargets, permissions }), dependencies: [playgroundTargets, key] });
+    // Stable ref callback registers the actual node on attach and releases on detach;
+    // an ordinary rerender must never temporarily revert assistant routing to inline.
+    const registerCanvas = useCallback((node) => controller?.attach({ target: node }), [controller]);
+    return { denied: !canMountPlayground({ permissions }), registerCanvas,
+        // CSS sibling matching keeps the canvas a pure portal target, with no React-owned children.
+        styles: '.jini-playground-canvas{display:flex;flex-direction:column;gap:1rem}.jini-playground-empty{display:none}.jini-playground-canvas:empty + .jini-playground-empty{display:block}',
+    };
+}
+//# sourceMappingURL=Canvas.hooks.js.map

package/dist/playground/react/hooks/PlaygroundPage.hooks.d.ts

@@ -0,0 +1,8 @@
+import type { ModulePageProps } from '../../../react/bind-react.js';
+export declare function usePlaygroundPage(props: ModulePageProps, _optional?: {}): {
+    denied: boolean;
+    ActiveTab: import("react").LazyExoticComponent<import("react").ComponentType<import("../../../react/bind-react.js").TabViewProps>> | undefined;
+    params: Readonly<Record<string, unknown>>;
+    permissions: readonly string[];
+};
+//# sourceMappingURL=PlaygroundPage.hooks.d.ts.map

package/dist/playground/react/hooks/PlaygroundPage.hooks.js

@@ -0,0 +1,2 @@
+export function usePlaygroundPage(props, _optional = {}) { const tab = props.description.tabs.find(t => t.visible); return { denied: !props.description.visible, ActiveTab: tab ? props.tabs.canvas : undefined, params: tab?.params ?? {}, permissions: props.description.grants }; }
+//# sourceMappingURL=PlaygroundPage.hooks.js.map

package/dist/playground/react/hooks/PlaygroundPorts.hooks.d.ts

@@ -0,0 +1,4 @@
+import type { PlaygroundPorts } from '../../ports.js';
+export declare const PlaygroundPortsContext: import("react").Context<PlaygroundPorts | null>;
+export declare function usePlaygroundPorts(_required?: Record<string, never>, _optional?: {}): PlaygroundPorts;
+//# sourceMappingURL=PlaygroundPorts.hooks.d.ts.map

package/dist/playground/react/hooks/PlaygroundPorts.hooks.js

@@ -0,0 +1,6 @@
+import { createContext, useContext } from 'react';
+import { AdminConfigError } from '../../../core/module/index.js';
+export const PlaygroundPortsContext = createContext(null);
+export function usePlaygroundPorts(_required = {}, _optional = {}) { const ports = useContext(PlaygroundPortsContext); if (!ports)
+    throw new AdminConfigError({ issues: ['React scope unavailable: playground'] }); return ports; }
+//# sourceMappingURL=PlaygroundPorts.hooks.js.map