@jarenjs/studio 0.83.3 → 0.85.0

package/dist/types/component/flow/mount.d.ts

@@ -0,0 +1,66 @@
+/** Assemble the shared Flow component. The public mount exposes only document operations. */
+import { createApp } from '@jarenjs/app';
+import { createFlowController } from '../../flow-editor.js';
+/** @param {HTMLElement|null} node @param {any} options
+ * @returns {{ app: ReturnType<typeof createApp>, editor: Pick<ReturnType<typeof createFlowController>, 'read'|'validate'|'replace'|'apply'|'run'|'subscribe'|'dispose'> }} */
+export declare function createFlowEditor(node: HTMLElement | null, options: any): {
+    app: ReturnType<typeof createApp>;
+    editor: Pick<ReturnType<typeof createFlowController>, 'read' | 'validate' | 'replace' | 'apply' | 'run' | 'subscribe' | 'dispose'>;
+};
+/**
+ * @param {HTMLElement|null} node
+ * @param {{ kind?: 'fsm'|'dag'|null, document?: any, input?: any, templates?: any[],
+ *   template?: (name: string) => any, tasks?: Record<string, Function>,
+ *   schedule?: (flush: () => void) => void, onError?: (error: Error) => void }} [options]
+ */
+export declare function mountFlowEditor(node: HTMLElement | null, options?: {
+    kind?: 'fsm' | 'dag' | null;
+    document?: any;
+    input?: any;
+    templates?: any[];
+    template?: (name: string) => any;
+    tasks?: Record<string, Function>;
+    schedule?: (flush: () => void) => void;
+    onError?: (error: Error) => void;
+}): Pick<{
+    read: () => import("../../flow-editor.js").FlowSnapshot;
+    validate: (candidate: any, kind?: 'fsm' | 'dag') => {
+        valid: boolean;
+        kind: string;
+        total: number;
+        errors: Array<{
+            code: string | null;
+            message: string;
+            docPath?: string;
+        }>;
+    } | {
+        valid: boolean;
+        errors: {
+            code: any;
+            message: any;
+            docPath: any;
+        }[];
+    };
+    replace: (candidate: any, options?: {
+        expectedRevision?: string;
+        kind?: 'fsm' | 'dag';
+    }) => Promise<import("../../flow-editor.js").EditorReceipt>;
+    apply: (patch: Parameters<typeof import("@jarenjs/json").applyJSONPatch>[1], options?: {
+        expectedRevision?: string;
+        kind?: 'fsm' | 'dag';
+    }) => Promise<import("../../flow-editor.js").EditorReceipt>;
+    run: (options?: {
+        input?: any;
+        event?: string;
+    }) => Promise<import("../../flow-editor.js").EditorReceipt>;
+    subscribe: (listener: (snapshot: import("../../flow-editor.js").FlowSnapshot) => void) => () => void;
+    attach: () => void;
+    effects: {
+        'flow-accepted': (id: any) => void;
+        'flow-refused': (id: any) => void;
+        'flow-editor-run': ((props: any, dispatch: any) => Promise<void>) & {
+            dispose: () => void;
+        };
+    };
+    dispose: () => void;
+}, "apply" | "dispose" | "read" | "replace" | "run" | "subscribe" | "validate">;

package/dist/types/component/flow/project-widget.d.ts

@@ -0,0 +1,8 @@
+export declare function createProjectFlowWidget(env?: {}): {
+    mount(host: any, props: any, emit: any): {
+        host: any;
+        emit: any;
+    };
+    update(h: any, props: any): void;
+    unmount: (h: any) => void;
+};

package/dist/types/component/flow/runtime.d.ts

@@ -0,0 +1,57 @@
+/** Read a JSON Pointer from a document (the inspector's selection). */
+export declare function memberAt(doc: any, pointer: any): any;
+/** @param {'fsm'|'dag'} kind @param {any} doc @returns {string} */
+export declare function flowText(kind: 'fsm' | 'dag', doc: any): string;
+/**
+ * The text pane is read-only when the document carries members the
+ * diagram text cannot represent — committing an edit would silently
+ * destroy them (APP-INTEGRATION honesty rule, MERMAID-FORMAT §5.1).
+ * @param {'fsm'|'dag'} kind @param {any} doc
+ * @returns {string|null} the human explanation, or null when editable
+ */
+export declare function textLossReason(kind: 'fsm' | 'dag', doc: any): string | null;
+/**
+ * @param {any} flow - the `state.flow` slice
+ * @returns {any} the `$.ui.flow` node
+ */
+export declare function flowPageViewModel(flow: any, templates?: any[]): any;
+/**
+ * The Flow studio runtime: the nested-app host widget for machine runs
+ * and the effect registry (template loading, fail-closed text parsing,
+ * machine sends, dag runs with abort). One closure ref ties the
+ * running instances to their effects.
+ * @param {{ schedule?: any, template?: (name: string) => any, tasks?: Record<string, Function>, getFlow?: () => any, mintFromCount?: boolean }} [env]
+ */
+export declare function createFlowRuntime(env?: {
+    schedule?: any;
+    template?: (name: string) => any;
+    tasks?: Record<string, Function>;
+    getFlow?: () => any;
+    mintFromCount?: boolean;
+}): {
+    widget: {
+        mount: Function;
+        update: Function;
+        unmount: Function;
+    };
+    effects: {
+        'flow-mint': (props: any, dispatch: any) => void;
+        'flow-template': (props: any, dispatch: any) => void;
+        'flow-parse': (props: any, dispatch: any) => void;
+        'flow-run-send': (props: any) => void;
+        'flow-dag-run': (props: any, dispatch: any) => Promise<{
+            ok: boolean;
+            error: string;
+            output?: undefined;
+        } | {
+            error?: undefined;
+            ok: boolean;
+            output: any;
+        } | {
+            ok: boolean;
+            error: string;
+        }>;
+        'flow-dag-abort': () => void;
+    };
+    dispose: () => void;
+};

package/dist/types/component/flow/views.d.ts

@@ -0,0 +1,242 @@
+/**
+ * The Flow studio — mode 'flow', dispatched with `$.ui.flow` as the
+ * current node. One jaren-fsm or jaren-dag document, edited three ways
+ * that cannot disagree: clicking the diagram (every gesture an RFC 6902
+ * patch), the forms-generated inspector, and the mermaid text pane —
+ * plus a live run mode where the same document boots a nested
+ * @jarenjs/app (machines) or a compileDag run (dataflow).
+ *
+ * The stylesheet renders derived projections only; the document itself
+ * lives at `state.flow.doc` and every mutation goes through the
+ * actions' patches — no pane owns private truth.
+ *
+ * Below the breakpoint the three cards become one pane at a time behind
+ * the shared segmented switcher (Diagram · Inspector · Run); selecting
+ * a node jumps to the inspector and running jumps to the run pane, so a
+ * phone never leaves the user looking at the pane they just left.
+ */
+export declare const FLOW_RULES: ({
+    match: string;
+    mode: string;
+    body: (string | {
+        $apply?: undefined;
+        class: string;
+    } | {
+        $apply: string;
+        class?: undefined;
+    })[];
+} | {
+    match: string;
+    mode: string;
+    body: (string | (string | {
+        $apply: string;
+    }[] | {
+        class: string;
+    })[] | {
+        key: string;
+    })[];
+} | {
+    match: string;
+    mode: string;
+    body: (string | (string | {}[] | (string | {
+        type: string;
+        class: string;
+        on: {
+            click: {
+                action: string;
+                with: string;
+            };
+        };
+    })[] | {
+        class: string;
+    })[] | {
+        class: string;
+    })[];
+} | {
+    match: string;
+    mode: string;
+    body: (string | (string | (string | {
+        type: string;
+        class: {
+            $if: (string | {
+                $eq: string[];
+            })[];
+        };
+        'aria-pressed': {
+            $if: (string | {
+                $eq: string[];
+            })[];
+        };
+        on: {
+            click: {
+                action: string;
+                with: string;
+            };
+        };
+    })[] | {
+        class: string;
+        role: string;
+        'aria-label': string;
+    })[] | (string | (string | (string | {}[] | {
+        class: string;
+    })[] | {
+        key: string;
+        class: string;
+        $if?: undefined;
+    } | {
+        key?: undefined;
+        $if: (string | (string | {
+            key: string;
+            $if?: undefined;
+        } | {
+            key?: undefined;
+            $if: (string | {}[] | {}[])[];
+        })[] | (string | (string | {
+            class: string;
+            rows: number;
+            spellcheck: string;
+            value: string;
+            on: {
+                input: string;
+                change: string;
+            };
+        })[] | (string | (string | {
+            type: string;
+            class: string;
+            on: {
+                click: string;
+            };
+        })[] | {
+            class: string;
+            $if?: undefined;
+        } | {
+            $if: (string | (string | {
+                type: string;
+                class: string;
+                on: {
+                    click: string;
+                };
+            })[])[];
+            class?: undefined;
+        })[] | {
+            key: string;
+            $if?: undefined;
+        } | {
+            key?: undefined;
+            $if: (string | (string | (string | {
+                $for: {
+                    l: string;
+                };
+                $return: (string | {
+                    class: string;
+                })[];
+            }[] | {
+                class: string;
+            })[] | {
+                $if?: undefined;
+            } | {
+                $if: (string | (string | {}[] | {
+                    class: string;
+                })[])[];
+            })[])[];
+        })[])[];
+        class?: undefined;
+    })[] | (string | (string | {}[] | {
+        class: string;
+        $if?: undefined;
+    } | {
+        $if: (string | (string | {
+            class: string;
+        })[])[];
+        class?: undefined;
+    })[] | {
+        key: string;
+        class: string;
+        $if?: undefined;
+    } | {
+        key?: undefined;
+        $if: (string | (string | {
+            class: string;
+        })[] | (string | {
+            key: string;
+            $apply?: undefined;
+        } | {
+            key?: undefined;
+            $apply: string;
+        })[])[];
+        class?: undefined;
+    })[] | {
+        key: string;
+        class: string;
+    })[] | (string | (string | (string | {
+        type: string;
+        class: {
+            $if: (string | {
+                $eq: string[];
+            })[];
+        };
+        on: {
+            click: {
+                action: string;
+                with: string;
+            };
+        };
+    })[] | {
+        class: string;
+    })[] | (string | (string | {
+        $if?: undefined;
+    } | {
+        $if: string[];
+    })[] | (string | any[] | {
+        class: string;
+        $if?: undefined;
+    } | {
+        $if: (string | any[])[];
+        class?: undefined;
+    })[] | {
+        class: string;
+    })[] | {
+        key: string;
+        class: string;
+        $if?: undefined;
+    } | {
+        $if: ((string | {
+            key: string;
+            class: string;
+        })[] | (string | (string | {
+            class: string;
+            rows: number;
+            spellcheck: string;
+            value: string;
+            readonly: {
+                $if: (string | boolean)[];
+            };
+            on: {
+                change: string;
+            };
+        })[] | {
+            key: string;
+            $if?: undefined;
+        } | {
+            key?: undefined;
+            $if: (string | (string | {
+                class: string;
+            })[])[];
+        })[] | {
+            $eq: string[];
+        })[];
+        key?: undefined;
+        class?: undefined;
+    } | {
+        key?: undefined;
+        $if: (string | (string | {
+            class: string;
+        })[])[];
+        class?: undefined;
+    })[] | {
+        key: string;
+        class: string;
+        'data-pane': string;
+    })[];
+})[];
+export declare const FLOW_FORM_RULES: any[];

package/dist/types/component/host.d.ts

@@ -8,7 +8,7 @@
  * is skipped.
  *
  * `reconcileBuffer` (editor buffer ↔ document): a CLEAN buffer adopts an
- * incoming write (share / undo / an AI edit lands); a DIRTY buffer whose
+ * incoming write (share / undo / an external edit lands); a DIRTY buffer whose
  * text differs from the incoming write keeps the human's text and records
  * the write as a recoverable draft — never a silent clobber, never a
  * hidden write.
@@ -24,7 +24,7 @@
 export declare function hostPolicy(prevProject: any, nextProject: any): Record<string, 'reboot' | 'hot' | 'skip'>;
 /**
  * Reconcile the editor's local typing buffer against an incoming
- * committed text (a share/undo restore, or an AI write onto the same
+ * committed text (a share/undo restore, or an external write onto the same
  * file). A clean buffer adopts; a dirty buffer that already matches the
  * incoming text simply clears (the commit landed); a dirty buffer that
  * differs keeps the human's text and surfaces the incoming version as a

package/dist/types/component/index.d.ts

@@ -1,13 +1,7 @@
 /**
- * @file The Studio COMPONENT — the IDE. Following the suite's component
- * convention (`createXComponent`), `createStudioComponent(options)` hands
- * the host the pieces it composes into the site's `@jarenjs/app` document:
- * the JSLT view (`rules` + `mode`), the derivation (`viewModel`), the two
- * hard-problem policies (`hostPolicy`, `reconcileBuffer`), and the engine
- * surface. The reducer `project/*` actions, the DOM stage/splitter
- * widgets, and the live site mount are wired at the host; the chrome and
- * its derivation — everything renderable without a DOM — live here and
- * are tested headlessly.
+ * The complete project editor and composable host pieces. A host can mount
+ * the editor directly, or compose the same actions, projections and controller
+ * into its application. Preview runners, templates and storage are injected.
  */
 import { classifyChange, parseProject } from '../index.js';
 import { projectViewModel } from './viewmodel.js';
@@ -75,13 +69,12 @@ export declare function createStudioComponent(options?: {
             class: string;
             $if?: undefined;
         } | {
-            class?: undefined;
             $if: (string | (string | {
                 class: string;
                 role: string;
             })[])[];
-        } | {
             class?: undefined;
+        } | {
             $if: ((string | (string | {
                 name: {
                     $default: string[];
@@ -90,12 +83,12 @@ export declare function createStudioComponent(options?: {
             })[] | {
                 class: string;
             })[] | {
-                $if?: undefined;
                 $eq: string[];
+                $if?: undefined;
             } | {
                 $if: ({
-                    $if?: undefined;
                     $eq: string[];
+                    $if?: undefined;
                 } | {
                     $eq?: undefined;
                     $if: (string | (string | {
@@ -113,6 +106,7 @@ export declare function createStudioComponent(options?: {
                 })[];
                 $eq?: undefined;
             })[];
+            class?: undefined;
         })[] | (string | (string | {
             class: string;
             type: string;
@@ -235,7 +229,6 @@ export declare function createStudioComponent(options?: {
         })[] | (string | {
             class: string;
         })[] | {
-            $if?: undefined;
             type: string;
             class: {
                 $if: string[];
@@ -247,8 +240,8 @@ export declare function createStudioComponent(options?: {
                     with: string;
                 };
             };
+            $if?: undefined;
         } | {
-            class?: undefined;
             type?: undefined;
             title?: undefined;
             on?: undefined;
@@ -256,6 +249,7 @@ export declare function createStudioComponent(options?: {
                 class: string;
                 title: string;
             })[])[];
+            class?: undefined;
         })[] | {
             class: string;
         })[];
@@ -301,3 +295,15 @@ export declare function createStudioComponent(options?: {
     parseProject: typeof parseProject;
 };
 export { projectViewModel, projectRules, projectModes, PROJECT_MODE, PROJECT_BASE, hostPolicy, reconcileBuffer, editorTextarea, errorLine, KIND_BADGE, };
+export { createStudioDocumentHost } from './document.js';
+export { createProjectHost } from './project.js';
+export { p, cards, table, callout, code, errorMessage, error, details, chart, article, search, more } from './shared/nodes.js';
+export { tabRule, UI_RULES } from './shared/ui.js';
+export { memo1 } from './shared/memo.js';
+export { OUR_SCHEMA_OPTIONS } from './shared/schema-options.js';
+export { createHostWidget } from './shared/host-widget.js';
+export { PROJECT_ACTIONS } from './project-actions.js';
+export { createProjectState } from './project-state.js';
+export { createProjectController } from './project-controller.js';
+export { mountStudioEditor } from './mount.js';
+export { editorTextarea as sharedEditorTextarea, errorLine as editorErrorLine, paneSwitcher } from './shared/studio-kit.js';

package/dist/types/component/mount.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Execution, document rendering, seeds and private data ownership are host services.
+ * The returned surface publishes document operations; the app state stays private.
+ * @param {HTMLElement | null} node
+ * @param {{ project: object, host: any, projectData?: any, projectTemplate?: Function,
+ *   templates?: any[], widgets?: Record<string, any>, schedule?: (flush: () => void) => void,
+ *   debounceMs?: number, download?: Function, exportProject?: Function, onError?: (error: Error) => void }} options
+ */
+export declare function mountStudioEditor(node: HTMLElement | null, options: {
+    project: object;
+    host: any;
+    projectData?: any;
+    projectTemplate?: Function;
+    templates?: any[];
+    widgets?: Record<string, any>;
+    schedule?: (flush: () => void) => void;
+    debounceMs?: number;
+    download?: Function;
+    exportProject?: Function;
+    onError?: (error: Error) => void;
+}): {
+    read: () => import("./project-controller.js").ProjectSnapshot;
+    validate: (candidate: any) => {
+        valid: boolean;
+        errors: any;
+        total: any;
+        document: any;
+    } | {
+        document?: undefined;
+        valid: boolean;
+        errors: {
+            code: any;
+            message: any;
+            docPath: any;
+        }[];
+        total: number;
+    };
+    replace: (candidate: any, { expectedRevision }?: {
+        expectedRevision?: string;
+    }) => Promise<import("./project-controller.js").EditorReceipt>;
+    apply: (patch: Parameters<typeof import("@jarenjs/json").applyJSONPatch>[1], options?: {
+        expectedRevision?: string;
+    }) => Promise<import("./project-controller.js").EditorReceipt>;
+    run: (name?: string, options?: {
+        restart?: boolean;
+    }) => Promise<import("./project-controller.js").EditorReceipt> | {
+        error: string;
+    };
+    subscribe: (listener: (snapshot: import("./project-controller.js").ProjectSnapshot) => void) => () => void;
+    dispose(): void;
+};