@syntrologie/adapt-content 0.0.0-semantically-released

package/dist/editor.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Adaptive Content - Editor Module
+ *
+ * Editor panel for configuring content modifications.
+ */
+import type { EditorPanelProps } from './types';
+/**
+ * Content editor panel component.
+ */
+export declare function ContentEditor({ config: _config, onChange: _onChange, editor: _editor, }: EditorPanelProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * Editor module configuration.
+ */
+export declare const editor: {
+    panel: {
+        title: string;
+        icon: string;
+        description: string;
+    };
+    component: typeof ContentEditor;
+};
+//# sourceMappingURL=editor.d.ts.map

package/dist/editor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"editor.d.ts","sourceRoot":"","sources":["../src/editor.tsx"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAEhD;;GAEG;AACH,wBAAgB,aAAa,CAAC,EAC5B,MAAM,EAAE,OAAO,EACf,QAAQ,EAAE,SAAS,EACnB,MAAM,EAAE,OAAO,GAChB,EAAE,gBAAgB,2CAOlB;AAED;;GAEG;AACH,eAAO,MAAM,MAAM;;;;;;;CAOlB,CAAC"}

package/dist/editor.js

@@ -0,0 +1,18 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * Content editor panel component.
+ */
+export function ContentEditor({ config: _config, onChange: _onChange, editor: _editor, }) {
+    return (_jsxs("div", { className: "syntro-content-editor", children: [_jsx("p", { children: "Content editor coming soon..." }), _jsx("p", { children: "Configure text replacements, attribute changes, and style modifications." })] }));
+}
+/**
+ * Editor module configuration.
+ */
+export const editor = {
+    panel: {
+        title: 'Content',
+        icon: '📝',
+        description: 'Text and attribute modifications',
+    },
+    component: ContentEditor,
+};

package/dist/runtime.d.ts

@@ -0,0 +1,83 @@
+/**
+ * Adaptive Content - Runtime Module
+ *
+ * DOM manipulation actions: insertHtml, setText, setAttr, addClass, removeClass, setStyle.
+ * These follow the hostPatcher snapshot pattern for safe reversibility.
+ */
+import type { InsertHtmlAction, SetTextAction, SetAttrAction, AddClassAction, RemoveClassAction, SetStyleAction, ActionExecutor } from './types';
+/**
+ * Execute an insertHtml action
+ */
+export declare const executeInsertHtml: ActionExecutor<InsertHtmlAction>;
+/**
+ * Execute a setText action
+ */
+export declare const executeSetText: ActionExecutor<SetTextAction>;
+/**
+ * Execute a setAttr action
+ */
+export declare const executeSetAttr: ActionExecutor<SetAttrAction>;
+/**
+ * Execute an addClass action
+ */
+export declare const executeAddClass: ActionExecutor<AddClassAction>;
+/**
+ * Execute a removeClass action
+ */
+export declare const executeRemoveClass: ActionExecutor<RemoveClassAction>;
+/**
+ * Execute a setStyle action
+ */
+export declare const executeSetStyle: ActionExecutor<SetStyleAction>;
+/**
+ * All executors provided by this app.
+ * These are registered with the runtime's ExecutorRegistry.
+ */
+export declare const executors: readonly [{
+    readonly kind: "content:insertHtml";
+    readonly executor: ActionExecutor<InsertHtmlAction>;
+}, {
+    readonly kind: "content:setText";
+    readonly executor: ActionExecutor<SetTextAction>;
+}, {
+    readonly kind: "content:setAttr";
+    readonly executor: ActionExecutor<SetAttrAction>;
+}, {
+    readonly kind: "content:addClass";
+    readonly executor: ActionExecutor<AddClassAction>;
+}, {
+    readonly kind: "content:removeClass";
+    readonly executor: ActionExecutor<RemoveClassAction>;
+}, {
+    readonly kind: "content:setStyle";
+    readonly executor: ActionExecutor<SetStyleAction>;
+}];
+/**
+ * App runtime manifest.
+ */
+export declare const runtime: {
+    id: string;
+    version: string;
+    name: string;
+    description: string;
+    executors: readonly [{
+        readonly kind: "content:insertHtml";
+        readonly executor: ActionExecutor<InsertHtmlAction>;
+    }, {
+        readonly kind: "content:setText";
+        readonly executor: ActionExecutor<SetTextAction>;
+    }, {
+        readonly kind: "content:setAttr";
+        readonly executor: ActionExecutor<SetAttrAction>;
+    }, {
+        readonly kind: "content:addClass";
+        readonly executor: ActionExecutor<AddClassAction>;
+    }, {
+        readonly kind: "content:removeClass";
+        readonly executor: ActionExecutor<RemoveClassAction>;
+    }, {
+        readonly kind: "content:setStyle";
+        readonly executor: ActionExecutor<SetStyleAction>;
+    }];
+};
+//# sourceMappingURL=runtime.d.ts.map

package/dist/runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../src/runtime.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EACV,gBAAgB,EAChB,aAAa,EACb,aAAa,EACb,cAAc,EACd,iBAAiB,EACjB,cAAc,EAEd,cAAc,EACf,MAAM,SAAS,CAAC;AAOjB;;GAEG;AACH,eAAO,MAAM,iBAAiB,EAAE,cAAc,CAAC,gBAAgB,CAmE9D,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,cAAc,EAAE,cAAc,CAAC,aAAa,CA+BxD,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,cAAc,EAAE,cAAc,CAAC,aAAa,CA2CxD,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,eAAe,EAAE,cAAc,CAAC,cAAc,CA8B1D,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,kBAAkB,EAAE,cAAc,CAAC,iBAAiB,CA8BhE,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,eAAe,EAAE,cAAc,CAAC,cAAc,CA+C1D,CAAC;AAMF;;;GAGG;AACH,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;EAOZ,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;CAMnB,CAAC"}

package/dist/runtime.js

@@ -0,0 +1,265 @@
+/**
+ * Adaptive Content - Runtime Module
+ *
+ * DOM manipulation actions: insertHtml, setText, setAttr, addClass, removeClass, setStyle.
+ * These follow the hostPatcher snapshot pattern for safe reversibility.
+ */
+import { sanitizeHtml } from './sanitizer';
+// ============================================================================
+// Executors
+// ============================================================================
+/**
+ * Execute an insertHtml action
+ */
+export const executeInsertHtml = async (action, context) => {
+    const anchorEl = context.resolveAnchor(action.anchorId);
+    if (!anchorEl) {
+        throw new Error(`Anchor not found: ${action.anchorId}`);
+    }
+    // Sanitize HTML content using context utility
+    const sanitizedHtml = sanitizeHtml(action.html);
+    // Create container for inserted content
+    const container = document.createElement('div');
+    container.setAttribute('data-syntro-action-id', context.generateId());
+    container.innerHTML = sanitizedHtml;
+    // Keep track of original state for replace position
+    let originalContent = null;
+    switch (action.position) {
+        case 'before':
+            anchorEl.insertAdjacentElement('beforebegin', container);
+            break;
+        case 'after':
+            anchorEl.insertAdjacentElement('afterend', container);
+            break;
+        case 'prepend':
+            anchorEl.insertBefore(container, anchorEl.firstChild);
+            break;
+        case 'append':
+            anchorEl.appendChild(container);
+            break;
+        case 'replace':
+            originalContent = anchorEl.innerHTML;
+            anchorEl.replaceWith(container);
+            break;
+    }
+    context.publishEvent('action.applied', {
+        id: context.generateId(),
+        kind: 'content:insertHtml',
+        anchorId: action.anchorId,
+        position: action.position,
+    });
+    return {
+        cleanup: () => {
+            if (action.position === 'replace' && originalContent !== null) {
+                // Restore original element
+                const restoredEl = document.createElement(anchorEl.tagName);
+                restoredEl.innerHTML = originalContent;
+                // Copy attributes
+                Array.from(anchorEl.attributes).forEach((attr) => {
+                    restoredEl.setAttribute(attr.name, attr.value);
+                });
+                container.replaceWith(restoredEl);
+            }
+            else {
+                container.remove();
+            }
+        },
+        updateFn: (changes) => {
+            if ('html' in changes && typeof changes.html === 'string') {
+                container.innerHTML = sanitizeHtml(changes.html);
+            }
+        },
+    };
+};
+/**
+ * Execute a setText action
+ */
+export const executeSetText = async (action, context) => {
+    const anchorEl = context.resolveAnchor(action.anchorId);
+    if (!anchorEl) {
+        throw new Error(`Anchor not found: ${action.anchorId}`);
+    }
+    // Snapshot original text
+    const originalText = anchorEl.textContent ?? '';
+    // Set new text
+    anchorEl.textContent = action.text;
+    context.publishEvent('action.applied', {
+        id: context.generateId(),
+        kind: 'content:setText',
+        anchorId: action.anchorId,
+    });
+    return {
+        cleanup: () => {
+            anchorEl.textContent = originalText;
+        },
+        updateFn: (changes) => {
+            if ('text' in changes && typeof changes.text === 'string') {
+                anchorEl.textContent = changes.text;
+            }
+        },
+    };
+};
+/**
+ * Execute a setAttr action
+ */
+export const executeSetAttr = async (action, context) => {
+    const anchorEl = context.resolveAnchor(action.anchorId);
+    if (!anchorEl) {
+        throw new Error(`Anchor not found: ${action.anchorId}`);
+    }
+    // Block dangerous attributes
+    const dangerousAttrs = ['onclick', 'onerror', 'onload', 'onmouseover', 'onfocus', 'onblur'];
+    if (dangerousAttrs.includes(action.attr.toLowerCase()) || action.attr.startsWith('on')) {
+        throw new Error(`Dangerous attribute not allowed: ${action.attr}`);
+    }
+    // Snapshot original attribute value
+    const originalValue = anchorEl.getAttribute(action.attr);
+    const hadAttribute = anchorEl.hasAttribute(action.attr);
+    // Set new attribute
+    anchorEl.setAttribute(action.attr, action.value);
+    context.publishEvent('action.applied', {
+        id: context.generateId(),
+        kind: 'content:setAttr',
+        anchorId: action.anchorId,
+        attr: action.attr,
+    });
+    return {
+        cleanup: () => {
+            if (hadAttribute && originalValue !== null) {
+                anchorEl.setAttribute(action.attr, originalValue);
+            }
+            else {
+                anchorEl.removeAttribute(action.attr);
+            }
+        },
+        updateFn: (changes) => {
+            if ('value' in changes && typeof changes.value === 'string') {
+                anchorEl.setAttribute(action.attr, changes.value);
+            }
+        },
+    };
+};
+/**
+ * Execute an addClass action
+ */
+export const executeAddClass = async (action, context) => {
+    const anchorEl = context.resolveAnchor(action.anchorId);
+    if (!anchorEl) {
+        throw new Error(`Anchor not found: ${action.anchorId}`);
+    }
+    // Check if class was already present
+    const hadClass = anchorEl.classList.contains(action.className);
+    // Add class
+    anchorEl.classList.add(action.className);
+    context.publishEvent('action.applied', {
+        id: context.generateId(),
+        kind: 'content:addClass',
+        anchorId: action.anchorId,
+        className: action.className,
+    });
+    return {
+        cleanup: () => {
+            // Only remove if we added it
+            if (!hadClass) {
+                anchorEl.classList.remove(action.className);
+            }
+        },
+    };
+};
+/**
+ * Execute a removeClass action
+ */
+export const executeRemoveClass = async (action, context) => {
+    const anchorEl = context.resolveAnchor(action.anchorId);
+    if (!anchorEl) {
+        throw new Error(`Anchor not found: ${action.anchorId}`);
+    }
+    // Check if class was present
+    const hadClass = anchorEl.classList.contains(action.className);
+    // Remove class
+    anchorEl.classList.remove(action.className);
+    context.publishEvent('action.applied', {
+        id: context.generateId(),
+        kind: 'content:removeClass',
+        anchorId: action.anchorId,
+        className: action.className,
+    });
+    return {
+        cleanup: () => {
+            // Only re-add if we removed it
+            if (hadClass) {
+                anchorEl.classList.add(action.className);
+            }
+        },
+    };
+};
+/**
+ * Execute a setStyle action
+ */
+export const executeSetStyle = async (action, context) => {
+    const anchorEl = context.resolveAnchor(action.anchorId);
+    if (!anchorEl) {
+        throw new Error(`Anchor not found: ${action.anchorId}`);
+    }
+    // Snapshot original styles
+    const originalStyles = new Map();
+    for (const prop of Object.keys(action.styles)) {
+        const current = anchorEl.style.getPropertyValue(prop);
+        originalStyles.set(prop, current);
+    }
+    // Apply new styles
+    for (const [prop, value] of Object.entries(action.styles)) {
+        anchorEl.style.setProperty(prop, value);
+    }
+    context.publishEvent('action.applied', {
+        id: context.generateId(),
+        kind: 'content:setStyle',
+        anchorId: action.anchorId,
+        styles: Object.keys(action.styles),
+    });
+    return {
+        cleanup: () => {
+            // Restore original styles
+            for (const [prop, originalValue] of originalStyles) {
+                if (originalValue) {
+                    anchorEl.style.setProperty(prop, originalValue);
+                }
+                else {
+                    anchorEl.style.removeProperty(prop);
+                }
+            }
+        },
+        updateFn: (changes) => {
+            if ('styles' in changes && typeof changes.styles === 'object' && changes.styles) {
+                for (const [prop, value] of Object.entries(changes.styles)) {
+                    anchorEl.style.setProperty(prop, value);
+                }
+            }
+        },
+    };
+};
+// ============================================================================
+// Executor Definitions for Registration
+// ============================================================================
+/**
+ * All executors provided by this app.
+ * These are registered with the runtime's ExecutorRegistry.
+ */
+export const executors = [
+    { kind: 'content:insertHtml', executor: executeInsertHtml },
+    { kind: 'content:setText', executor: executeSetText },
+    { kind: 'content:setAttr', executor: executeSetAttr },
+    { kind: 'content:addClass', executor: executeAddClass },
+    { kind: 'content:removeClass', executor: executeRemoveClass },
+    { kind: 'content:setStyle', executor: executeSetStyle },
+];
+/**
+ * App runtime manifest.
+ */
+export const runtime = {
+    id: 'adaptive-content',
+    version: '1.0.0',
+    name: 'Content',
+    description: 'DOM manipulation for text, attributes, and styles',
+    executors,
+};

package/dist/sanitizer.d.ts

@@ -0,0 +1,8 @@
+/**
+ * HTML Sanitizer
+ *
+ * Sanitizes HTML to prevent XSS attacks.
+ * Uses native Sanitizer API when available, falls back to whitelist approach.
+ */
+export declare function sanitizeHtml(html: string): string;
+//# sourceMappingURL=sanitizer.d.ts.map

package/dist/sanitizer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sanitizer.d.ts","sourceRoot":"","sources":["../src/sanitizer.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAwBH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAqDjD"}

package/dist/sanitizer.js

@@ -0,0 +1,75 @@
+/**
+ * HTML Sanitizer
+ *
+ * Sanitizes HTML to prevent XSS attacks.
+ * Uses native Sanitizer API when available, falls back to whitelist approach.
+ */
+const ALLOWED_TAGS = new Set([
+    'b',
+    'strong',
+    'i',
+    'em',
+    'u',
+    'span',
+    'div',
+    'p',
+    'br',
+    'ul',
+    'ol',
+    'li',
+    'code',
+    'pre',
+    'small',
+    'sup',
+    'sub',
+    'a',
+    'button',
+]);
+export function sanitizeHtml(html) {
+    // Try native Sanitizer API first
+    const hasNative = typeof window.Sanitizer === 'function';
+    if (hasNative) {
+        try {
+            const s = new window.Sanitizer({});
+            const frag = s.sanitizeToFragment(html);
+            const div = document.createElement('div');
+            div.append(frag);
+            return div.innerHTML;
+        }
+        catch {
+            // Fall through to manual sanitizer
+        }
+    }
+    // Conservative fallback sanitizer
+    const tpl = document.createElement('template');
+    tpl.innerHTML = html;
+    const root = tpl.content;
+    const walker = document.createTreeWalker(root, NodeFilter.SHOW_ELEMENT, null);
+    const toRemove = [];
+    while (walker.nextNode()) {
+        const el = walker.currentNode;
+        const tag = el.tagName.toLowerCase();
+        if (!ALLOWED_TAGS.has(tag)) {
+            toRemove.push(el);
+            continue;
+        }
+        // Remove dangerous attributes
+        for (const attr of Array.from(el.attributes)) {
+            const name = attr.name.toLowerCase();
+            const value = attr.value.trim().toLowerCase();
+            const isEvent = name.startsWith('on');
+            const isJsUrl = (name === 'href' || name === 'src') && value.startsWith('javascript:');
+            if (isEvent || isJsUrl) {
+                el.removeAttribute(attr.name);
+            }
+        }
+    }
+    // Remove disallowed elements but keep their children
+    for (const el of toRemove) {
+        while (el.firstChild) {
+            el.parentNode?.insertBefore(el.firstChild, el);
+        }
+        el.remove();
+    }
+    return tpl.innerHTML;
+}

package/dist/schema.d.ts

@@ -0,0 +1,140 @@
+/**
+ * Adaptive Content - Config Schema
+ *
+ * Zod schema for validating content app configuration.
+ */
+import { z } from 'zod';
+/**
+ * Content app config schema.
+ * Defines the structure for content modifications in a canvas config.
+ */
+export declare const configSchema: z.ZodObject<{
+    /** Text replacements */
+    textReplacements: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        anchorId: z.ZodString;
+        text: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        anchorId: string;
+        text: string;
+    }, {
+        anchorId: string;
+        text: string;
+    }>, "many">>;
+    /** Attribute modifications */
+    attributeChanges: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        anchorId: z.ZodString;
+        attr: z.ZodString;
+        value: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        anchorId: string;
+        attr: string;
+        value: string;
+    }, {
+        anchorId: string;
+        attr: string;
+        value: string;
+    }>, "many">>;
+    /** Style modifications */
+    styleChanges: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        anchorId: z.ZodString;
+        styles: z.ZodRecord<z.ZodString, z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        anchorId: string;
+        styles: Record<string, string>;
+    }, {
+        anchorId: string;
+        styles: Record<string, string>;
+    }>, "many">>;
+    /** HTML insertions */
+    htmlInsertions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        anchorId: z.ZodString;
+        html: z.ZodString;
+        position: z.ZodEnum<["before", "after", "prepend", "append", "replace"]>;
+    }, "strip", z.ZodTypeAny, {
+        anchorId: string;
+        html: string;
+        position: "before" | "after" | "prepend" | "append" | "replace";
+    }, {
+        anchorId: string;
+        html: string;
+        position: "before" | "after" | "prepend" | "append" | "replace";
+    }>, "many">>;
+    /** Class additions */
+    classAdditions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        anchorId: z.ZodString;
+        className: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        anchorId: string;
+        className: string;
+    }, {
+        anchorId: string;
+        className: string;
+    }>, "many">>;
+    /** Class removals */
+    classRemovals: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        anchorId: z.ZodString;
+        className: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        anchorId: string;
+        className: string;
+    }, {
+        anchorId: string;
+        className: string;
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    textReplacements?: {
+        anchorId: string;
+        text: string;
+    }[] | undefined;
+    attributeChanges?: {
+        anchorId: string;
+        attr: string;
+        value: string;
+    }[] | undefined;
+    styleChanges?: {
+        anchorId: string;
+        styles: Record<string, string>;
+    }[] | undefined;
+    htmlInsertions?: {
+        anchorId: string;
+        html: string;
+        position: "before" | "after" | "prepend" | "append" | "replace";
+    }[] | undefined;
+    classAdditions?: {
+        anchorId: string;
+        className: string;
+    }[] | undefined;
+    classRemovals?: {
+        anchorId: string;
+        className: string;
+    }[] | undefined;
+}, {
+    textReplacements?: {
+        anchorId: string;
+        text: string;
+    }[] | undefined;
+    attributeChanges?: {
+        anchorId: string;
+        attr: string;
+        value: string;
+    }[] | undefined;
+    styleChanges?: {
+        anchorId: string;
+        styles: Record<string, string>;
+    }[] | undefined;
+    htmlInsertions?: {
+        anchorId: string;
+        html: string;
+        position: "before" | "after" | "prepend" | "append" | "replace";
+    }[] | undefined;
+    classAdditions?: {
+        anchorId: string;
+        className: string;
+    }[] | undefined;
+    classRemovals?: {
+        anchorId: string;
+        className: string;
+    }[] | undefined;
+}>;
+export type ContentConfig = z.infer<typeof configSchema>;
+//# sourceMappingURL=schema.d.ts.map

package/dist/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;GAGG;AACH,eAAO,MAAM,YAAY;IACvB,wBAAwB;;;;;;;;;;;IAUxB,8BAA8B;;;;;;;;;;;;;;IAW9B,0BAA0B;;;;;;;;;;;IAU1B,sBAAsB;;;;;;;;;;;;;;IAWtB,sBAAsB;;;;;;;;;;;IAUtB,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EASrB,CAAC;AAEH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC"}

package/dist/schema.js

@@ -0,0 +1,56 @@
+/**
+ * Adaptive Content - Config Schema
+ *
+ * Zod schema for validating content app configuration.
+ */
+import { z } from 'zod';
+/**
+ * Content app config schema.
+ * Defines the structure for content modifications in a canvas config.
+ */
+export const configSchema = z.object({
+    /** Text replacements */
+    textReplacements: z
+        .array(z.object({
+        anchorId: z.string(),
+        text: z.string(),
+    }))
+        .optional(),
+    /** Attribute modifications */
+    attributeChanges: z
+        .array(z.object({
+        anchorId: z.string(),
+        attr: z.string(),
+        value: z.string(),
+    }))
+        .optional(),
+    /** Style modifications */
+    styleChanges: z
+        .array(z.object({
+        anchorId: z.string(),
+        styles: z.record(z.string()),
+    }))
+        .optional(),
+    /** HTML insertions */
+    htmlInsertions: z
+        .array(z.object({
+        anchorId: z.string(),
+        html: z.string(),
+        position: z.enum(['before', 'after', 'prepend', 'append', 'replace']),
+    }))
+        .optional(),
+    /** Class additions */
+    classAdditions: z
+        .array(z.object({
+        anchorId: z.string(),
+        className: z.string(),
+    }))
+        .optional(),
+    /** Class removals */
+    classRemovals: z
+        .array(z.object({
+        anchorId: z.string(),
+        className: z.string(),
+    }))
+        .optional(),
+});

package/dist/types.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Types from @syntrologie/runtime-sdk
+ *
+ * Minimal type definitions for building this app independently.
+ * These match the types exported from @syntrologie/runtime-sdk/types.
+ */
+export interface EditorPanelProps {
+    config: Record<string, unknown>;
+    onChange: (config: Record<string, unknown>) => void;
+    editor: {
+        setDirty: (dirty: boolean) => void;
+        navigateHome: () => Promise<boolean>;
+        save: () => Promise<void>;
+        publish: (captureScreenshot?: boolean) => Promise<void>;
+    };
+    platformClient?: unknown;
+}
+export type InsertPosition = 'before' | 'after' | 'prepend' | 'append' | 'replace';
+interface BaseAction {
+    label?: string;
+}
+export interface InsertHtmlAction extends BaseAction {
+    kind: 'content:insertHtml';
+    anchorId: string;
+    html: string;
+    position: InsertPosition;
+}
+export interface SetTextAction extends BaseAction {
+    kind: 'content:setText';
+    anchorId: string;
+    text: string;
+}
+export interface SetAttrAction extends BaseAction {
+    kind: 'content:setAttr';
+    anchorId: string;
+    attr: string;
+    value: string;
+}
+export interface AddClassAction extends BaseAction {
+    kind: 'content:addClass';
+    anchorId: string;
+    className: string;
+}
+export interface RemoveClassAction extends BaseAction {
+    kind: 'content:removeClass';
+    anchorId: string;
+    className: string;
+}
+export interface SetStyleAction extends BaseAction {
+    kind: 'content:setStyle';
+    anchorId: string;
+    styles: Record<string, string>;
+}
+export type ExecutorCleanup = () => void | Promise<void>;
+export type ExecutorUpdate = (changes: Record<string, unknown>) => void | Promise<void>;
+export interface ExecutorResult {
+    cleanup: ExecutorCleanup;
+    updateFn?: ExecutorUpdate;
+}
+export interface ExecutorContext {
+    overlayRoot: HTMLElement;
+    resolveAnchor: (anchorId: string) => HTMLElement | null;
+    generateId: () => string;
+    publishEvent: (name: string, props?: Record<string, unknown>) => void;
+    adaptiveId?: string;
+}
+export type ActionExecutor<T> = (action: T, context: ExecutorContext) => Promise<ExecutorResult>;
+export {};
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAQH,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAChC,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,CAAC;IACpD,MAAM,EAAE;QACN,QAAQ,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;QACnC,YAAY,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,CAAC;QACrC,IAAI,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;QAC1B,OAAO,EAAE,CAAC,iBAAiB,CAAC,EAAE,OAAO,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;KACzD,CAAC;IACF,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B;AAMD,MAAM,MAAM,cAAc,GAAG,QAAQ,GAAG,OAAO,GAAG,SAAS,GAAG,QAAQ,GAAG,SAAS,CAAC;AAEnF,UAAU,UAAU;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,gBAAiB,SAAQ,UAAU;IAClD,IAAI,EAAE,oBAAoB,CAAC;IAC3B,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,cAAc,CAAC;CAC1B;AAED,MAAM,WAAW,aAAc,SAAQ,UAAU;IAC/C,IAAI,EAAE,iBAAiB,CAAC;IACxB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,aAAc,SAAQ,UAAU;IAC/C,IAAI,EAAE,iBAAiB,CAAC;IACxB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,cAAe,SAAQ,UAAU;IAChD,IAAI,EAAE,kBAAkB,CAAC;IACzB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,iBAAkB,SAAQ,UAAU;IACnD,IAAI,EAAE,qBAAqB,CAAC;IAC5B,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,cAAe,SAAQ,UAAU;IAChD,IAAI,EAAE,kBAAkB,CAAC;IACzB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAChC;AAMD,MAAM,MAAM,eAAe,GAAG,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;AACzD,MAAM,MAAM,cAAc,GAAG,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;AAExF,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,eAAe,CAAC;IACzB,QAAQ,CAAC,EAAE,cAAc,CAAC;CAC3B;AAED,MAAM,WAAW,eAAe;IAC9B,WAAW,EAAE,WAAW,CAAC;IACzB,aAAa,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,WAAW,GAAG,IAAI,CAAC;IACxD,UAAU,EAAE,MAAM,MAAM,CAAC;IACzB,YAAY,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,CAAC;IACtE,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,MAAM,cAAc,CAAC,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE,OAAO,EAAE,eAAe,KAAK,OAAO,CAAC,cAAc,CAAC,CAAC"}

package/dist/types.js

@@ -0,0 +1,7 @@
+/**
+ * Types from @syntrologie/runtime-sdk
+ *
+ * Minimal type definitions for building this app independently.
+ * These match the types exported from @syntrologie/runtime-sdk/types.
+ */
+export {};

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@syntrologie/adapt-content",
+  "version": "0.0.0-semantically-released",
+  "description": "Adaptive Content app - DOM manipulation actions for text, attributes, and styles",
+  "license": "Proprietary",
+  "private": false,
+  "author": "Syntrologie <eng@syntrologie.com>",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/SyntropyForge/amazing-demos.git",
+    "directory": "tech-core/sdks/adaptives/adaptive-content"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "exports": {
+    "./runtime": {
+      "types": "./dist/runtime.d.ts",
+      "import": "./dist/runtime.js"
+    },
+    "./schema": {
+      "types": "./dist/schema.d.ts",
+      "import": "./dist/schema.js"
+    },
+    "./editor": {
+      "types": "./dist/editor.d.ts",
+      "import": "./dist/editor.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "clean": "rm -rf dist"
+  },
+  "peerDependencies": {
+    "@syntrologie/runtime-sdk": "^2.0.0",
+    "react": ">=18.0.0",
+    "react-dom": ">=18.0.0",
+    "zod": "^3.0.0"
+  },
+  "devDependencies": {
+    "@floating-ui/dom": "^1.6.0",
+    "@types/react": "^18.0.0",
+    "typescript": "^5.0.0",
+    "zod": "^3.25.0"
+  }
+}