agentic-zi-ui 0.0.1

package/CHANGELOG.md

@@ -0,0 +1,7 @@
+# Changelog
+
+All notable changes to this package will be documented in this file.
+
+## [Unreleased]
+- Initial renderer extraction as `agentic-zi-ui`
+- Export branded component `ZijusCustomWidget`

package/RELEASE.md

@@ -0,0 +1,10 @@
+# Release checklist (agentic-zi-ui)
+
+1) Update `CHANGELOG.md`
+2) Bump version
+   - `pnpm -C packages/ui-renderer release:patch`
+   - or `release:minor` / `release:major`
+3) Build
+   - `pnpm -C packages/ui-renderer build`
+4) Publish
+   - `pnpm -C packages/ui-renderer publish:public`

package/dist/UiRenderer.d.ts

@@ -0,0 +1,16 @@
+import type { UiNode, UiTemplate, UiActionType, WidgetDefinition } from "@acme/ui-schema";
+export type RenderPolicy = {
+    allowedTags?: string[];
+    allowedProps?: string[];
+    allowedActions?: UiActionType[];
+};
+export type UiRendererProps = {
+    template: UiTemplate;
+    data?: Record<string, unknown>;
+    onFlowEvent: (name: string, payload?: Record<string, unknown>) => void;
+    resolveWidget?: (widgetId: string) => Promise<WidgetDefinition>;
+    slots?: Record<string, Array<UiNode | string>>;
+    policy?: RenderPolicy;
+};
+export declare function UiRenderer({ template, data, onFlowEvent, resolveWidget, slots, policy, }: UiRendererProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=UiRenderer.d.ts.map

package/dist/UiRenderer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"UiRenderer.d.ts","sourceRoot":"","sources":["../src/UiRenderer.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,MAAM,EACN,UAAU,EAEV,YAAY,EACZ,gBAAgB,EACjB,MAAM,iBAAiB,CAAC;AAczB,MAAM,MAAM,YAAY,GAAG;IACzB,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;IACvB,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB,cAAc,CAAC,EAAE,YAAY,EAAE,CAAC;CACjC,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG;IAC5B,QAAQ,EAAE,UAAU,CAAC;IACrB,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC/B,WAAW,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,CAAC;IACvE,aAAa,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,gBAAgB,CAAC,CAAC;IAChE,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,MAAM,GAAG,MAAM,CAAC,CAAC,CAAC;IAC/C,MAAM,CAAC,EAAE,YAAY,CAAC;CACvB,CAAC;AAkQF,wBAAgB,UAAU,CAAC,EACzB,QAAQ,EACR,IAAI,EACJ,WAAW,EACX,aAAa,EACb,KAAK,EACL,MAAM,GACP,EAAE,eAAe,2CAkPjB"}

package/dist/UiRenderer.js

@@ -0,0 +1,384 @@
+import { jsxs as _jsxs, jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import React, { useMemo, useReducer, useEffect, useState } from "react";
+import { UI_ALLOWED_TAGS, UI_ALLOWED_PROPS, UiActionTypeSchema, } from "@acme/ui-schema";
+import { runAction } from "./actions";
+const BASE_ALLOWED_TAGS = new Set(UI_ALLOWED_TAGS);
+const BASE_ALLOWED_PROPS = new Set(UI_ALLOWED_PROPS);
+const BASE_ALLOWED_ACTIONS = new Set(UiActionTypeSchema.options);
+function reducer(state, action) {
+    switch (action.type) {
+        case "patch":
+            return { ...state, [action.key]: action.value };
+        default:
+            return state;
+    }
+}
+function resolvePath(data, keyPath) {
+    const parts = keyPath.split(".").map((p) => p.trim()).filter(Boolean);
+    let current = data;
+    for (const part of parts) {
+        if (current == null)
+            return undefined;
+        current = current[part];
+    }
+    return current;
+}
+function interpolateValue(s, data) {
+    const fullMatch = s.match(/^\s*\{\{([^}]+)\}\}\s*$/);
+    if (fullMatch) {
+        const keyPath = fullMatch[1].trim();
+        const v = resolvePath(data, keyPath);
+        return v === undefined || v === null ? "" : v;
+    }
+    return s.replace(/\{\{([^}]+)\}\}/g, (_m, rawKey) => {
+        const keyPath = String(rawKey).trim();
+        const v = resolvePath(data, keyPath);
+        return v === undefined || v === null ? "" : String(v);
+    });
+}
+function interpolateString(s, data) {
+    const v = interpolateValue(s, data);
+    return typeof v === "string" ? v : v === undefined || v === null ? "" : String(v);
+}
+function deepInterpolate(value, data) {
+    if (typeof value === "string")
+        return interpolateValue(value, data);
+    if (Array.isArray(value))
+        return value.map((v) => deepInterpolate(v, data));
+    if (value && typeof value === "object") {
+        const out = {};
+        for (const [k, v] of Object.entries(value)) {
+            out[k] = deepInterpolate(v, data);
+        }
+        return out;
+    }
+    return value;
+}
+function isSafeHttpUrl(url) {
+    try {
+        const parsed = new URL(url);
+        return parsed.protocol === "https:" || parsed.protocol === "http:";
+    }
+    catch {
+        return false;
+    }
+}
+function isSafeImageUrl(url) {
+    if (url.startsWith("data:image/"))
+        return true;
+    return isSafeHttpUrl(url);
+}
+function pickSafeProps(raw) {
+    if (!raw || typeof raw !== "object")
+        return {};
+    // Only allow a small safe subset
+    const out = {};
+    for (const k of Object.keys(raw)) {
+        if (BASE_ALLOWED_PROPS.has(k) ||
+            k.startsWith("aria-") ||
+            k.startsWith("data-")) {
+            out[k] = raw[k];
+        }
+    }
+    for (const key of ["disabled", "checked", "aria-disabled", "aria-hidden"]) {
+        const value = out[key];
+        if (typeof value === "string") {
+            const normalized = value.trim().toLowerCase();
+            if (normalized === "true")
+                out[key] = true;
+            if (normalized === "false")
+                out[key] = false;
+        }
+    }
+    return out;
+}
+function intersect(left, right) {
+    if (!right || right.length === 0)
+        return new Set(left);
+    const rightSet = new Set(right);
+    const out = new Set();
+    for (const item of left) {
+        if (rightSet.has(item))
+            out.add(item);
+    }
+    return out;
+}
+function mergePolicies(base, next) {
+    if (!base && !next)
+        return undefined;
+    return {
+        allowedTags: base?.allowedTags && next?.allowedTags
+            ? base.allowedTags.filter((t) => next.allowedTags?.includes(t))
+            : base?.allowedTags ?? next?.allowedTags,
+        allowedProps: base?.allowedProps && next?.allowedProps
+            ? base.allowedProps.filter((p) => next.allowedProps?.includes(p))
+            : base?.allowedProps ?? next?.allowedProps,
+        allowedActions: base?.allowedActions && next?.allowedActions
+            ? base.allowedActions.filter((a) => next.allowedActions?.includes(a))
+            : base?.allowedActions ?? next?.allowedActions,
+    };
+}
+function normalizeWidgetProps(widget, raw) {
+    if (!widget.props) {
+        return { props: raw };
+    }
+    const props = {};
+    for (const [key, def] of Object.entries(widget.props)) {
+        if (!(key in raw)) {
+            if (def.default !== undefined) {
+                props[key] = def.default;
+                continue;
+            }
+            if (def.required) {
+                return { props: {}, error: `Missing required prop: ${key}` };
+            }
+            continue;
+        }
+        const value = raw[key];
+        if (def.type === "string" && typeof value !== "string") {
+            return { props: {}, error: `Invalid prop type for ${key}` };
+        }
+        if (def.type === "number" && typeof value !== "number") {
+            return { props: {}, error: `Invalid prop type for ${key}` };
+        }
+        if (def.type === "boolean" && typeof value !== "boolean") {
+            return { props: {}, error: `Invalid prop type for ${key}` };
+        }
+        if (def.type === "json") {
+            props[key] = value;
+            continue;
+        }
+        props[key] = value;
+    }
+    return { props };
+}
+function normalizeWidgetSlots(widget, slots) {
+    const provided = slots ?? {};
+    if (widget.slots) {
+        for (const [name, cfg] of Object.entries(widget.slots)) {
+            if (cfg.required && (!provided[name] || provided[name].length === 0)) {
+                return { slots: {}, error: `Missing required slot: ${name}` };
+            }
+        }
+    }
+    return { slots: provided };
+}
+function WidgetNode(props) {
+    const { node, resolveWidget } = props;
+    const [widget, setWidget] = useState(null);
+    const [error, setError] = useState(null);
+    const widgetId = typeof node.widgetId === "string" ? node.widgetId : "";
+    useEffect(() => {
+        if (!widgetId) {
+            // eslint-disable-next-line react-hooks/set-state-in-effect
+            setError("Missing widgetId.");
+            return;
+        }
+        if (!resolveWidget) {
+            setError("Widget resolver not configured.");
+            return;
+        }
+        let cancelled = false;
+        setWidget(null);
+        setError(null);
+        resolveWidget(widgetId)
+            .then((def) => {
+            if (!cancelled)
+                setWidget(def);
+        })
+            .catch((e) => {
+            if (!cancelled)
+                setError(e?.message ?? String(e));
+        });
+        return () => {
+            cancelled = true;
+        };
+    }, [widgetId, resolveWidget]);
+    if (error) {
+        return _jsxs("div", { className: "text-xs text-red-600", children: ["Widget error: ", error] });
+    }
+    if (!widget) {
+        return _jsx("div", { className: "text-xs text-slate-500", children: "Loading widget\u2026" });
+    }
+    const { props: widgetProps, error: propError } = normalizeWidgetProps(widget, node.widgetProps ?? {});
+    if (propError) {
+        return _jsx("div", { className: "text-xs text-red-600", children: propError });
+    }
+    const { slots, error: slotError } = normalizeWidgetSlots(widget, node.slots);
+    if (slotError) {
+        return _jsx("div", { className: "text-xs text-red-600", children: slotError });
+    }
+    const mergedData = { ...props.data, ...widgetProps };
+    const mergedPolicy = mergePolicies(props.policy, widget.policy);
+    return (_jsx(UiRenderer, { template: widget.template, data: mergedData, onFlowEvent: props.onFlowEvent, resolveWidget: props.resolveWidget, slots: slots, policy: mergedPolicy }));
+}
+export function UiRenderer({ template, data, onFlowEvent, resolveWidget, slots, policy, }) {
+    const [state, dispatch] = useReducer(reducer, {});
+    const mergedData = useMemo(() => ({ ...(data ?? {}), state }), [data, state]);
+    const allowedTags = useMemo(() => intersect(BASE_ALLOWED_TAGS, policy?.allowedTags), [policy?.allowedTags]);
+    const allowedProps = useMemo(() => intersect(BASE_ALLOWED_PROPS, policy?.allowedProps), [policy?.allowedProps]);
+    const allowedActions = useMemo(() => intersect(BASE_ALLOWED_ACTIONS, policy?.allowedActions), [policy?.allowedActions]);
+    const ctx = useMemo(() => ({
+        sendFlowEvent: (name, payload) => {
+            const interpolatedPayload = deepInterpolate(payload ?? {}, mergedData);
+            onFlowEvent(name, interpolatedPayload);
+        },
+        patchState: (key, value) => dispatch({ type: "patch", key, value }),
+        getState: (key) => state[key],
+        toast: (message) => {
+            // POC: swap with your notification system
+            alert(message);
+        },
+    }), [mergedData, onFlowEvent, state]);
+    function attachEvent(action, handler) {
+        if (!action)
+            return undefined;
+        return handler;
+    }
+    function renderNode(node, idxPath) {
+        const tag = node.type;
+        if (tag === "slot") {
+            const slotNodes = slots?.[node.slotName] ?? [];
+            if (slotNodes.length === 0)
+                return null;
+            return (_jsx(React.Fragment, { children: slotNodes.map((c, i) => {
+                    const childPath = `${idxPath}.slot.${i}`;
+                    if (typeof c === "string")
+                        return interpolateString(c, mergedData);
+                    return renderNode(c, childPath);
+                }) }, idxPath));
+        }
+        if (tag === "widget") {
+            return (_jsx(WidgetNode, { node: node, data: mergedData, onFlowEvent: (name, payload) => ctx.sendFlowEvent(name, payload), resolveWidget: resolveWidget, policy: policy }, idxPath));
+        }
+        if (!allowedTags.has(tag)) {
+            return (_jsxs("div", { className: "text-xs text-red-600", children: ["Blocked tag: ", _jsx("span", { className: "font-mono", children: tag })] }, idxPath));
+        }
+        const className = node.className
+            ? interpolateString(node.className, mergedData)
+            : undefined;
+        const rawProps = node.props
+            ? deepInterpolate(node.props, mergedData)
+            : undefined;
+        const safeProps = pickSafeProps(rawProps);
+        for (const k of Object.keys(safeProps)) {
+            if (!allowedProps.has(k))
+                delete safeProps[k];
+        }
+        // Bindings (POC)
+        if (tag === "input") {
+            if (node.bind?.valueKey) {
+                safeProps.value = (ctx.getState(node.bind.valueKey) ?? "");
+            }
+            if (node.bind?.checkedKey) {
+                safeProps.checked = !!ctx.getState(node.bind.checkedKey);
+            }
+        }
+        // Events
+        const onClick = attachEvent(node.events?.onClick, async () => {
+            if (node.events?.onClick)
+                await runAction(node.events.onClick, ctx, undefined, allowedActions);
+        });
+        const onChange = attachEvent(node.events?.onChange, async (ev) => {
+            if (node.events?.onChange)
+                await runAction(node.events.onChange, ctx, ev, allowedActions);
+        });
+        const onSubmit = attachEvent(node.events?.onSubmit, async (ev) => {
+            ev?.preventDefault?.();
+            if (node.events?.onSubmit)
+                await runAction(node.events.onSubmit, ctx, ev, allowedActions);
+        });
+        const onMouseEnter = attachEvent(node.events?.onMouseEnter, async (ev) => {
+            if (node.events?.onMouseEnter)
+                await runAction(node.events.onMouseEnter, ctx, ev, allowedActions);
+        });
+        const onMouseLeave = attachEvent(node.events?.onMouseLeave, async (ev) => {
+            if (node.events?.onMouseLeave)
+                await runAction(node.events.onMouseLeave, ctx, ev, allowedActions);
+        });
+        const onMouseOver = attachEvent(node.events?.onMouseOver, async (ev) => {
+            if (node.events?.onMouseOver)
+                await runAction(node.events.onMouseOver, ctx, ev, allowedActions);
+        });
+        const onMouseOut = attachEvent(node.events?.onMouseOut, async (ev) => {
+            if (node.events?.onMouseOut)
+                await runAction(node.events.onMouseOut, ctx, ev, allowedActions);
+        });
+        const onMouseDown = attachEvent(node.events?.onMouseDown, async (ev) => {
+            if (node.events?.onMouseDown)
+                await runAction(node.events.onMouseDown, ctx, ev, allowedActions);
+        });
+        const onMouseUp = attachEvent(node.events?.onMouseUp, async (ev) => {
+            if (node.events?.onMouseUp)
+                await runAction(node.events.onMouseUp, ctx, ev, allowedActions);
+        });
+        const onMouseMove = attachEvent(node.events?.onMouseMove, async (ev) => {
+            if (node.events?.onMouseMove)
+                await runAction(node.events.onMouseMove, ctx, ev, allowedActions);
+        });
+        const onFocus = attachEvent(node.events?.onFocus, async (ev) => {
+            if (node.events?.onFocus)
+                await runAction(node.events.onFocus, ctx, ev, allowedActions);
+        });
+        const onBlur = attachEvent(node.events?.onBlur, async (ev) => {
+            if (node.events?.onBlur)
+                await runAction(node.events.onBlur, ctx, ev, allowedActions);
+        });
+        // Children
+        const children = (node.children ?? []).map((c, i) => {
+            const childPath = `${idxPath}.${i}`;
+            if (typeof c === "string")
+                return interpolateString(c, mergedData);
+            return renderNode(c, childPath);
+        });
+        if (tag === "a") {
+            if (typeof safeProps.href === "string") {
+                if (!isSafeHttpUrl(safeProps.href)) {
+                    delete safeProps.href;
+                }
+            }
+            else {
+                delete safeProps.href;
+            }
+            if (safeProps.target !== "_blank" && safeProps.target !== "_self") {
+                delete safeProps.target;
+            }
+            if (safeProps.target === "_blank") {
+                safeProps.rel = "noopener noreferrer";
+            }
+        }
+        if (tag === "img") {
+            if (typeof safeProps.src === "string") {
+                if (!isSafeImageUrl(safeProps.src)) {
+                    delete safeProps.src;
+                }
+            }
+            else {
+                delete safeProps.src;
+            }
+            if (typeof safeProps.alt !== "string") {
+                safeProps.alt = "";
+            }
+        }
+        const props = {
+            ...safeProps,
+            className,
+            onClick,
+            onChange,
+            onSubmit,
+            onMouseEnter,
+            onMouseLeave,
+            onMouseOver,
+            onMouseOut,
+            onMouseDown,
+            onMouseUp,
+            onMouseMove,
+            onFocus,
+            onBlur,
+            key: idxPath,
+        };
+        return React.createElement(tag, props, ...children);
+    }
+    return _jsx(_Fragment, { children: renderNode(template.root, "0") });
+}

package/dist/actions.d.ts

@@ -0,0 +1,9 @@
+import type { UiAction, UiActionType } from "@acme/ui-schema";
+export type ActionContext = {
+    sendFlowEvent: (name: string, payload?: Record<string, unknown>) => void;
+    patchState: (key: string, value: unknown) => void;
+    getState: (key: string) => unknown;
+    toast: (message: string) => void;
+};
+export declare function runAction(action: UiAction, ctx: ActionContext, ev?: unknown, allowedActions?: Set<UiActionType>): Promise<void>;
+//# sourceMappingURL=actions.d.ts.map

package/dist/actions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"actions.d.ts","sourceRoot":"","sources":["../src/actions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAE9D,MAAM,MAAM,aAAa,GAAG;IAC1B,aAAa,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,CAAC;IACzE,UAAU,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;IAClD,QAAQ,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC;IACnC,KAAK,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;CAClC,CAAC;AAWF,wBAAsB,SAAS,CAC7B,MAAM,EAAE,QAAQ,EAChB,GAAG,EAAE,aAAa,EAClB,EAAE,CAAC,EAAE,OAAO,EACZ,cAAc,CAAC,EAAE,GAAG,CAAC,YAAY,CAAC,GACjC,OAAO,CAAC,IAAI,CAAC,CAuDf"}

package/dist/actions.js

@@ -0,0 +1,84 @@
+function isSafeHttpUrl(url) {
+    try {
+        const u = new URL(url);
+        return u.protocol === "https:" || u.protocol === "http:";
+    }
+    catch {
+        return false;
+    }
+}
+export async function runAction(action, ctx, ev, allowedActions) {
+    if (allowedActions && !allowedActions.has(action.type)) {
+        ctx.toast("Blocked action");
+        return;
+    }
+    switch (action.type) {
+        case "FLOW_EVENT": {
+            const payload = substituteEventValues(action.payload ?? {}, ev);
+            ctx.sendFlowEvent(action.name, payload);
+            return;
+        }
+        case "OPEN_URL": {
+            if (!isSafeHttpUrl(action.url)) {
+                ctx.toast("Blocked unsafe URL");
+                return;
+            }
+            const target = action.target ?? "_blank";
+            window.open(action.url, target, "noopener,noreferrer");
+            return;
+        }
+        case "COPY": {
+            await navigator.clipboard.writeText(action.text);
+            ctx.toast("Copied");
+            return;
+        }
+        case "TOAST": {
+            ctx.toast(action.message);
+            return;
+        }
+        case "PATCH_STATE": {
+            if (action.value !== undefined) {
+                ctx.patchState(action.key, action.value);
+                return;
+            }
+            // valueFrom reads from event
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const e = ev;
+            if (action.valueFrom === "event.target.value") {
+                ctx.patchState(action.key, e?.target?.value);
+            }
+            else if (action.valueFrom === "event.target.checked") {
+                ctx.patchState(action.key, !!e?.target?.checked);
+            }
+            else {
+                ctx.patchState(action.key, null);
+            }
+            return;
+        }
+        default:
+            return;
+    }
+}
+function substituteEventValues(payload, ev) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const e = ev;
+    const value = e?.target?.value;
+    const checked = e?.target?.checked;
+    function walk(input) {
+        if (input === "$event.target.value")
+            return value ?? null;
+        if (input === "$event.target.checked")
+            return !!checked;
+        if (Array.isArray(input))
+            return input.map(walk);
+        if (input && typeof input === "object") {
+            const out = {};
+            for (const [k, v] of Object.entries(input)) {
+                out[k] = walk(v);
+            }
+            return out;
+        }
+        return input;
+    }
+    return walk(payload);
+}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+import type { UiRendererProps } from "./UiRenderer";
+export type { UiRendererProps, RenderPolicy } from "./UiRenderer";
+export type { UiRendererProps as ZijusCustomWidgetProps } from "./UiRenderer";
+export declare function ZijusCustomWidget(props: UiRendererProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AACpD,YAAY,EAAE,eAAe,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAElE,YAAY,EAAE,eAAe,IAAI,sBAAsB,EAAE,MAAM,cAAc,CAAC;AAE9E,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,eAAe,2CAEvD"}

package/dist/index.js

@@ -0,0 +1,5 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { UiRenderer } from "./UiRenderer";
+export function ZijusCustomWidget(props) {
+    return _jsx(UiRenderer, { ...props });
+}

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "agentic-zi-ui",
+  "version": "0.0.1",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "private": false,
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "dev": "tsc -w",
+    "build": "tsc",
+    "prepublishOnly": "pnpm -C . build",
+    "release:patch": "npm version patch -m \"chore(release): %s\"",
+    "release:minor": "npm version minor -m \"chore(release): %s\"",
+    "release:major": "npm version major -m \"chore(release): %s\"",
+    "publish:public": "npm publish --access public"
+  },
+  "dependencies": {
+    "@acme/ui-schema": "workspace:*"
+  },
+  "peerDependencies": {
+    "react": "^18 || ^19"
+  },
+  "devDependencies": {
+    "@types/react": "^19.2.5",
+    "typescript": "~5.9.3"
+  }
+}