@image-marker/web 0.1.0

package/lib/module/editor/core-contract.d.ts

@@ -0,0 +1,2 @@
+export * from '../core/index.js';
+export { default } from '../core/index.js';

package/lib/module/editor/core-contract.js

@@ -0,0 +1,2 @@
+export * from '../core/index.js';
+export { default } from '../core/index.js';

package/lib/module/editor/geometry.d.ts

@@ -0,0 +1,8 @@
+import type { EditorPoint, EditorSafeArea, EditorSnapContext, EditorSnapGuide } from './types.js';
+export declare function normalizeSafeArea(safeArea?: Partial<EditorSafeArea>): EditorSafeArea;
+export declare function snapLayerPosition(point: EditorPoint, context: EditorSnapContext): {
+    point: EditorPoint;
+    guides: EditorSnapGuide[];
+};
+export declare function distance(first: EditorPoint, second: EditorPoint): number;
+export declare function angle(first: EditorPoint, second: EditorPoint): number;

package/lib/module/editor/geometry.js

@@ -0,0 +1,103 @@
+const DEFAULT_SNAP_THRESHOLD = 6;
+function closest(value, candidates, threshold) {
+    return candidates
+        .map((candidate) => ({
+        ...candidate,
+        distance: Math.abs(candidate.value - value),
+    }))
+        .filter((candidate) => candidate.distance <= threshold)
+        .sort((left, right) => left.distance - right.distance)[0];
+}
+export function normalizeSafeArea(safeArea = {}) {
+    return {
+        top: Math.max(0, safeArea.top ?? 0),
+        right: Math.max(0, safeArea.right ?? 0),
+        bottom: Math.max(0, safeArea.bottom ?? 0),
+        left: Math.max(0, safeArea.left ?? 0),
+    };
+}
+export function snapLayerPosition(point, context) {
+    const safe = normalizeSafeArea(context.safeArea);
+    const threshold = context.threshold ?? DEFAULT_SNAP_THRESHOLD;
+    const canvasCenterX = context.canvas.width / 2;
+    const canvasCenterY = context.canvas.height / 2;
+    const layerCenterX = context.layer.width / 2;
+    const layerCenterY = context.layer.height / 2;
+    const right = context.canvas.width - safe.right - context.layer.width;
+    const bottom = context.canvas.height - safe.bottom - context.layer.height;
+    const xCandidates = [
+        {
+            value: 0,
+            guide: { axis: 'x', position: 0, kind: 'edge' },
+        },
+        {
+            value: safe.left,
+            guide: { axis: 'x', position: safe.left, kind: 'safe-area' },
+        },
+        {
+            value: canvasCenterX - layerCenterX,
+            guide: { axis: 'x', position: canvasCenterX, kind: 'center' },
+        },
+        {
+            value: right,
+            guide: {
+                axis: 'x',
+                position: context.canvas.width - safe.right,
+                kind: 'safe-area',
+            },
+        },
+        {
+            value: context.canvas.width - context.layer.width,
+            guide: {
+                axis: 'x',
+                position: context.canvas.width,
+                kind: 'edge',
+            },
+        },
+    ];
+    const yCandidates = [
+        {
+            value: 0,
+            guide: { axis: 'y', position: 0, kind: 'edge' },
+        },
+        {
+            value: safe.top,
+            guide: { axis: 'y', position: safe.top, kind: 'safe-area' },
+        },
+        {
+            value: canvasCenterY - layerCenterY,
+            guide: { axis: 'y', position: canvasCenterY, kind: 'center' },
+        },
+        {
+            value: bottom,
+            guide: {
+                axis: 'y',
+                position: context.canvas.height - safe.bottom,
+                kind: 'safe-area',
+            },
+        },
+        {
+            value: context.canvas.height - context.layer.height,
+            guide: {
+                axis: 'y',
+                position: context.canvas.height,
+                kind: 'edge',
+            },
+        },
+    ];
+    const snappedX = closest(point.x, xCandidates, threshold);
+    const snappedY = closest(point.y, yCandidates, threshold);
+    return {
+        point: {
+            x: snappedX?.value ?? point.x,
+            y: snappedY?.value ?? point.y,
+        },
+        guides: [snappedX?.guide, snappedY?.guide].filter((guide) => Boolean(guide)),
+    };
+}
+export function distance(first, second) {
+    return Math.hypot(second.x - first.x, second.y - first.y);
+}
+export function angle(first, second) {
+    return (Math.atan2(second.y - first.y, second.x - first.x) * 180) / Math.PI;
+}

package/lib/module/editor/headless.d.ts

@@ -0,0 +1,5 @@
+export { ImageMarkerEditorController } from './controller.js';
+export { angle, distance, normalizeSafeArea, snapLayerPosition, } from './geometry.js';
+export { createEditorViewportProjection, fitEditorSizeWithinMax, projectEditorPoint, projectEditorRecipe, unprojectEditorPoint, type EditorViewportProjection, } from './projection.js';
+export { createBrandLogoLayer, createBrandTextLayer, createEditorBrandKit, createEditorTemplate, materializeEditorTemplate, } from './presets.js';
+export type { EditorAlignment, EditorAsset, EditorAutosaveOptions, EditorBrandKit, EditorClipboardDocument, EditorContentCredentialsExport, EditorDistribution, EditorExportOptions, EditorExportResult, EditorInvisibleExport, EditorKeyCommand, EditorLayerBounds, EditorPoint, EditorRect, EditorRenderRequest, EditorSafeArea, EditorSelectionMode, EditorSerializedState, EditorSize, EditorSnapContext, EditorSnapGuide, EditorState, EditorTemplate, EditorTextLayerPatch, EditorViewportState, ImageMarkerEditorControllerOptions, ImageMarkerEditorRenderAdapter, MarkerImageInfo, WatermarkBlendMode, WatermarkRecipeDefinition, WatermarkRecipeDefinitionLayer, WatermarkRecipeDocument, WatermarkRecipeInput, WatermarkTextStyle, } from './types.js';

package/lib/module/editor/headless.js

@@ -0,0 +1,4 @@
+export { ImageMarkerEditorController } from './controller.js';
+export { angle, distance, normalizeSafeArea, snapLayerPosition, } from './geometry.js';
+export { createEditorViewportProjection, fitEditorSizeWithinMax, projectEditorPoint, projectEditorRecipe, unprojectEditorPoint, } from './projection.js';
+export { createBrandLogoLayer, createBrandTextLayer, createEditorBrandKit, createEditorTemplate, materializeEditorTemplate, } from './presets.js';

package/lib/module/editor/presets.d.ts

@@ -0,0 +1,19 @@
+import { type WatermarkRecipeDefinition, type WatermarkRecipeLayer, type WatermarkRecipeVariableContext } from '@image-marker/recipe';
+import type { EditorAsset, EditorBrandKit, EditorTemplate } from './types.js';
+export declare function createEditorBrandKit<Source = unknown>(brandKit: EditorBrandKit<Source>): EditorBrandKit<Source>;
+export declare function createEditorTemplate<Source = unknown>(template: EditorTemplate<Source>): EditorTemplate<Source>;
+/**
+ * Resolves `{{variable}}` placeholders and conditional layers with the same
+ * Recipe materializer used by Core, Node, and CLI.
+ */
+export declare function materializeEditorTemplate<Source = unknown>(template: EditorTemplate<Source>, context: WatermarkRecipeVariableContext): WatermarkRecipeDefinition<Source>;
+export declare function createBrandTextLayer(text: string, brandKit: EditorBrandKit, overrides?: Partial<Extract<WatermarkRecipeLayer, {
+    type: 'text';
+}>>): Extract<WatermarkRecipeLayer, {
+    type: 'text';
+}>;
+export declare function createBrandLogoLayer<Source>(asset: EditorAsset<Source>, overrides?: Partial<Extract<WatermarkRecipeLayer<Source>, {
+    type: 'image';
+}>>): Extract<WatermarkRecipeLayer<Source>, {
+    type: 'image';
+}>;

package/lib/module/editor/presets.js

@@ -0,0 +1,57 @@
+import { materializeWatermarkRecipe, migrateWatermarkRecipe, } from '@image-marker/recipe';
+function assertIdentifier(value, label) {
+    const normalized = value.trim();
+    if (!normalized)
+        throw new Error(`${label} must not be empty.`);
+    return normalized;
+}
+export function createEditorBrandKit(brandKit) {
+    return {
+        colors: brandKit.colors
+            ? [...new Set(brandKit.colors.map((color) => color.trim()))].filter(Boolean)
+            : undefined,
+        fonts: brandKit.fonts
+            ? [...new Set(brandKit.fonts.map((font) => font.trim()))].filter(Boolean)
+            : undefined,
+        logos: brandKit.logos?.map((logo) => ({ ...logo })),
+    };
+}
+export function createEditorTemplate(template) {
+    return {
+        ...template,
+        id: assertIdentifier(template.id, 'Template id'),
+        name: assertIdentifier(template.name, 'Template name'),
+        recipe: migrateWatermarkRecipe(template.recipe),
+        brandKit: template.brandKit
+            ? createEditorBrandKit(template.brandKit)
+            : undefined,
+    };
+}
+/**
+ * Resolves `{{variable}}` placeholders and conditional layers with the same
+ * Recipe materializer used by Core, Node, and CLI.
+ */
+export function materializeEditorTemplate(template, context) {
+    return materializeWatermarkRecipe(template.recipe, context);
+}
+export function createBrandTextLayer(text, brandKit, overrides = {}) {
+    return {
+        type: 'text',
+        text,
+        ...overrides,
+        style: {
+            color: brandKit.colors?.[0] ?? '#FFFFFF',
+            fontName: brandKit.fonts?.[0],
+            fontSize: 36,
+            ...overrides.style,
+        },
+    };
+}
+export function createBrandLogoLayer(asset, overrides = {}) {
+    return {
+        type: 'image',
+        src: asset.source,
+        name: asset.name,
+        ...overrides,
+    };
+}

package/lib/module/editor/projection.d.ts

@@ -0,0 +1,12 @@
+import type { EditorPoint, EditorRect, EditorSize, WatermarkRecipeDefinition } from './types.js';
+export interface EditorViewportProjection {
+    source: EditorSize;
+    viewport: EditorSize;
+    content: EditorRect;
+    scale: number;
+}
+export declare function fitEditorSizeWithinMax(source: EditorSize, maxSize: number): EditorSize;
+export declare function createEditorViewportProjection(source: EditorSize, viewport: EditorSize): EditorViewportProjection;
+export declare function projectEditorPoint(point: EditorPoint, projection: EditorViewportProjection): EditorPoint;
+export declare function unprojectEditorPoint(point: EditorPoint, projection: EditorViewportProjection): EditorPoint;
+export declare function projectEditorRecipe(recipe: WatermarkRecipeDefinition, source: EditorSize, target: EditorSize): WatermarkRecipeDefinition;

package/lib/module/editor/projection.js

@@ -0,0 +1,188 @@
+function assertSize(size, label) {
+    if (!Number.isFinite(size.width) ||
+        !Number.isFinite(size.height) ||
+        size.width <= 0 ||
+        size.height <= 0) {
+        throw new Error(`${label} dimensions must be finite numbers greater than 0.`);
+    }
+}
+function scaleMeasure(value, factor) {
+    if (typeof value === 'number')
+        return value * factor;
+    if (typeof value !== 'string')
+        return value;
+    const normalized = value.trim();
+    if (!normalized || normalized.endsWith('%'))
+        return value;
+    const parsed = Number(normalized);
+    return Number.isFinite(parsed) ? String(parsed * factor) : value;
+}
+function scalePadding(value, factor) {
+    if (typeof value === 'number')
+        return value * factor;
+    if (typeof value !== 'string')
+        return value;
+    return value
+        .trim()
+        .split(/\s+/)
+        .map((part) => scaleMeasure(part, factor))
+        .join(' ');
+}
+function projectPosition(layer, scaleX, scaleY, scale) {
+    const position = layer.position;
+    const defaultInset = layer.type === 'text' ? 20 : 0;
+    if (position?.position) {
+        return {
+            ...position,
+            X: scaleMeasure(position.X, scaleX),
+            Y: scaleMeasure(position.Y, scaleY),
+            edgeInset: position.edgeInset === undefined
+                ? 20 * scale
+                : scaleMeasure(position.edgeInset, scale),
+        };
+    }
+    return {
+        ...position,
+        X: position?.X === undefined
+            ? defaultInset * scaleX
+            : scaleMeasure(position.X, scaleX),
+        Y: position?.Y === undefined
+            ? defaultInset * scaleY
+            : scaleMeasure(position.Y, scaleY),
+        edgeInset: position?.edgeInset === undefined
+            ? undefined
+            : scaleMeasure(position.edgeInset, scale),
+    };
+}
+function projectLayout(layer, scaleX, scaleY) {
+    if (layer.layout?.type !== 'tile')
+        return layer.layout && { ...layer.layout };
+    return {
+        ...layer.layout,
+        gapX: scaleMeasure(layer.layout.gapX, scaleX),
+        gapY: scaleMeasure(layer.layout.gapY, scaleY),
+        offsetX: scaleMeasure(layer.layout.offsetX, scaleX),
+        offsetY: scaleMeasure(layer.layout.offsetY, scaleY),
+    };
+}
+function projectTextLayer(layer, scaleX, scaleY, scale) {
+    const style = layer.style;
+    const background = style?.textBackgroundStyle;
+    const cornerRadius = background?.cornerRadius;
+    return {
+        ...layer,
+        position: projectPosition(layer, scaleX, scaleY, scale),
+        layout: projectLayout(layer, scaleX, scaleY),
+        style: {
+            ...style,
+            fontSize: style?.fontSizeRatio === undefined
+                ? (style?.fontSize ?? 14) * scale
+                : style.fontSize,
+            shadowStyle: style?.shadowStyle
+                ? {
+                    ...style.shadowStyle,
+                    dx: style.shadowStyle.dx * scaleX,
+                    dy: style.shadowStyle.dy * scaleY,
+                    radius: style.shadowStyle.radius * scale,
+                }
+                : style?.shadowStyle,
+            strokeStyle: style?.strokeStyle
+                ? {
+                    ...style.strokeStyle,
+                    width: style.strokeStyle.width * scale,
+                }
+                : style?.strokeStyle,
+            textBackgroundStyle: background
+                ? {
+                    ...background,
+                    padding: scalePadding(background.padding, scale),
+                    paddingLeft: scaleMeasure(background.paddingLeft, scaleX),
+                    paddingRight: scaleMeasure(background.paddingRight, scaleX),
+                    paddingTop: scaleMeasure(background.paddingTop, scaleY),
+                    paddingBottom: scaleMeasure(background.paddingBottom, scaleY),
+                    paddingHorizontal: scaleMeasure(background.paddingHorizontal, scaleX),
+                    paddingVertical: scaleMeasure(background.paddingVertical, scaleY),
+                    paddingX: scaleMeasure(background.paddingX, scaleX),
+                    paddingY: scaleMeasure(background.paddingY, scaleY),
+                    cornerRadius: cornerRadius
+                        ? Object.fromEntries(Object.entries(cornerRadius).map(([key, value]) => [
+                            key,
+                            value
+                                ? {
+                                    x: scaleMeasure(value.x, scaleX),
+                                    y: scaleMeasure(value.y, scaleY),
+                                }
+                                : value,
+                        ]))
+                        : cornerRadius,
+                }
+                : background,
+        },
+    };
+}
+function projectImageLayer(layer, scaleX, scaleY, scale) {
+    return {
+        ...layer,
+        position: projectPosition(layer, scaleX, scaleY, scale),
+        layout: projectLayout(layer, scaleX, scaleY),
+        scale: (layer.scale ?? 1) * scale,
+    };
+}
+export function fitEditorSizeWithinMax(source, maxSize) {
+    assertSize(source, 'sourceSize');
+    if (!Number.isFinite(maxSize) || maxSize <= 0) {
+        throw new Error('maxSize must be a finite number greater than 0.');
+    }
+    const largest = Math.max(source.width, source.height);
+    if (largest <= maxSize)
+        return { ...source };
+    const scale = maxSize / largest;
+    return {
+        width: Math.max(1, Math.round(source.width * scale)),
+        height: Math.max(1, Math.round(source.height * scale)),
+    };
+}
+export function createEditorViewportProjection(source, viewport) {
+    assertSize(source, 'sourceSize');
+    assertSize(viewport, 'viewport');
+    const scale = Math.min(viewport.width / source.width, viewport.height / source.height);
+    const width = source.width * scale;
+    const height = source.height * scale;
+    return {
+        source: { ...source },
+        viewport: { ...viewport },
+        scale,
+        content: {
+            x: (viewport.width - width) / 2,
+            y: (viewport.height - height) / 2,
+            width,
+            height,
+        },
+    };
+}
+export function projectEditorPoint(point, projection) {
+    return {
+        x: projection.content.x + point.x * projection.scale,
+        y: projection.content.y + point.y * projection.scale,
+    };
+}
+export function unprojectEditorPoint(point, projection) {
+    return {
+        x: (point.x - projection.content.x) / projection.scale,
+        y: (point.y - projection.content.y) / projection.scale,
+    };
+}
+export function projectEditorRecipe(recipe, source, target) {
+    assertSize(source, 'sourceSize');
+    assertSize(target, 'targetSize');
+    const scaleX = target.width / source.width;
+    const scaleY = target.height / source.height;
+    const scale = Math.min(scaleX, scaleY);
+    return {
+        schemaVersion: 2,
+        layers: recipe.layers.map((layer) => layer.type === 'text'
+            ? projectTextLayer(layer, scaleX, scaleY, scale)
+            : projectImageLayer(layer, scaleX, scaleY, scale)),
+        output: { ...recipe.output },
+    };
+}

package/lib/module/editor/types.d.ts

@@ -0,0 +1,166 @@
+import type { ContentCredentialsAdapter, ContentCredentialsClaim, MarkerImageInfo, MarkerJobOptions, MarkerResult } from './core-contract.js';
+import type { WatermarkBlendMode, WatermarkRecipeDefinition, WatermarkRecipeDefinitionLayer, WatermarkRecipeDocument, WatermarkRecipeInput, WatermarkTextStyle } from '@image-marker/recipe';
+export interface EditorPoint {
+    x: number;
+    y: number;
+}
+export interface EditorSize {
+    width: number;
+    height: number;
+}
+export interface EditorRect extends EditorPoint, EditorSize {
+}
+export interface EditorViewportState {
+    zoom: number;
+    pan: EditorPoint;
+    fitMode: 'contain' | 'manual';
+}
+export interface EditorSafeArea {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+}
+export type EditorSnapGuide = {
+    axis: 'x';
+    position: number;
+    kind: 'edge' | 'center' | 'safe-area';
+} | {
+    axis: 'y';
+    position: number;
+    kind: 'edge' | 'center' | 'safe-area';
+};
+export interface EditorInvisibleExport {
+    payload: string;
+    key: string;
+    strength?: 'subtle' | 'balanced' | 'robust';
+}
+export interface EditorContentCredentialsExport {
+    adapter: ContentCredentialsAdapter;
+    claim: ContentCredentialsClaim;
+}
+export interface EditorExportOptions {
+    invisible?: EditorInvisibleExport;
+    contentCredentials?: EditorContentCredentialsExport;
+}
+export interface EditorState {
+    recipe: WatermarkRecipeDefinition;
+    /** Ordered selection. The final item is the primary selection. */
+    selectedLayerIds: readonly string[];
+    /** Convenience alias for the primary selection. */
+    selectedLayerId?: string;
+    safeArea: EditorSafeArea;
+    snapGuides: readonly EditorSnapGuide[];
+    exportOptions: EditorExportOptions;
+    viewport: EditorViewportState;
+    canUndo: boolean;
+    canRedo: boolean;
+}
+export type EditorSelectionMode = 'replace' | 'add' | 'toggle';
+export type EditorAlignment = 'left' | 'center' | 'right' | 'top' | 'middle' | 'bottom';
+export type EditorDistribution = 'horizontal' | 'vertical';
+export interface EditorLayerBounds extends EditorRect {
+    id: string;
+}
+export interface EditorClipboardDocument {
+    kind: 'image-marker/editor-layers';
+    version: 1;
+    layers: WatermarkRecipeDefinitionLayer[];
+}
+export type EditorTextLayerPatch = {
+    text?: string;
+    name?: string;
+    alpha?: number;
+    blendMode?: WatermarkBlendMode;
+    style?: Partial<WatermarkTextStyle>;
+};
+export interface EditorAsset<Source = unknown> {
+    id: string;
+    name: string;
+    source: Source;
+    thumbnail?: Source;
+    tags?: readonly string[];
+}
+export interface EditorBrandKit<Source = unknown> {
+    colors?: readonly string[];
+    fonts?: readonly string[];
+    logos?: readonly EditorAsset<Source>[];
+}
+export interface EditorTemplate<Source = unknown> {
+    id: string;
+    name: string;
+    description?: string;
+    recipe: WatermarkRecipeDocument<Source>;
+    brandKit?: EditorBrandKit<Source>;
+}
+export interface EditorPersistenceAdapter {
+    load(key: string): string | null | Promise<string | null>;
+    save(key: string, value: string): void | Promise<void>;
+    remove?(key: string): void | Promise<void>;
+}
+export interface EditorAutosaveOptions {
+    key: string;
+    storage: EditorPersistenceAdapter;
+    debounceMs?: number;
+    onError?: (error: Error) => void;
+}
+export interface ImageMarkerEditorControllerOptions {
+    document: WatermarkRecipeDocument;
+    historyLimit?: number;
+    autosave?: EditorAutosaveOptions;
+    onChange?: (state: EditorState) => void;
+}
+export interface EditorSerializedState {
+    version: 1;
+    recipe: WatermarkRecipeDefinition;
+    selectedLayerIds: string[];
+    safeArea: EditorSafeArea;
+    /**
+     * Reserved for non-sensitive application metadata. Core signing adapters,
+     * invisible-watermark keys, and export credentials are never autosaved.
+     */
+    exportOptions?: EditorExportOptions;
+    viewport: EditorViewportState;
+}
+export interface EditorSnapContext {
+    canvas: EditorSize;
+    layer: EditorSize;
+    safeArea?: EditorSafeArea;
+    threshold?: number;
+}
+export interface EditorKeyCommand {
+    key: string;
+    shiftKey?: boolean;
+    ctrlKey?: boolean;
+    metaKey?: boolean;
+    altKey?: boolean;
+}
+export interface EditorRenderRequest {
+    recipe: WatermarkRecipeDefinition;
+    input: WatermarkRecipeInput;
+    /**
+     * Pixel dimensions of the background before Core applies output.maxSize.
+     * Providing this keeps numeric Recipe coordinates visually stable between
+     * the interactive surface, bounded previews, and original export.
+     */
+    sourceSize?: EditorSize;
+    control?: MarkerJobOptions;
+}
+export interface EditorExportResult {
+    visible: MarkerResult;
+    final: MarkerResult;
+}
+/**
+ * Rendering remains injectable. The editor package owns interaction state,
+ * while Core or an application adapter owns image decoding and encoding.
+ */
+export interface ImageMarkerEditorRenderAdapter {
+    getSourceInfo?(source: unknown): Promise<MarkerImageInfo>;
+    renderPreview(request: EditorRenderRequest & {
+        maxSize?: number;
+    }): Promise<MarkerResult>;
+    exportOriginal(request: EditorRenderRequest & {
+        options?: EditorExportOptions;
+    }): Promise<EditorExportResult>;
+}
+export type { MarkerImageInfo, WatermarkBlendMode, WatermarkRecipeDefinition, WatermarkRecipeDefinitionLayer, WatermarkRecipeDocument, WatermarkRecipeInput, WatermarkTextStyle, };

package/lib/module/editor/types.js

@@ -0,0 +1 @@
+export {};

package/lib/module/editor-adapter.d.ts

@@ -0,0 +1,7 @@
+import type { EditorMarkerEngine } from './editor/adapter.js';
+import type { ImageMarkerEditorRenderAdapter, MarkerImageInfo } from './editor/types.js';
+export type { EditorMarkerEngine } from './editor/adapter.js';
+/** Bind the shared editor renderer to Canvas or an isolated Web Marker instance. */
+export declare function createWebEditorAdapter(previewMaxSize?: number, marker?: EditorMarkerEngine): ImageMarkerEditorRenderAdapter;
+/** Read local file bytes first; the default browser fallback remains available. */
+export declare function resolveWebEditorSourceInfo(source: unknown): Promise<MarkerImageInfo>;

package/lib/module/editor-adapter.js

@@ -0,0 +1,10 @@
+import Marker from './core/web/index.js';
+import { createEditorRenderAdapter } from './editor/adapter.js';
+/** Bind the shared editor renderer to Canvas or an isolated Web Marker instance. */
+export function createWebEditorAdapter(previewMaxSize = 1024, marker = Marker) {
+    return createEditorRenderAdapter(marker, previewMaxSize);
+}
+/** Read local file bytes first; the default browser fallback remains available. */
+export function resolveWebEditorSourceInfo(source) {
+    return Marker.getImageInfo(source);
+}

package/lib/module/headless.d.ts

@@ -0,0 +1,2 @@
+export * from './editor/headless.js';
+export { addWatermarkRecipeLayer, duplicateWatermarkRecipeLayer, groupWatermarkRecipeLayers, removeWatermarkRecipeLayer, reorderWatermarkRecipeLayer, ungroupWatermarkRecipeLayers, updateWatermarkRecipeLayer, } from '@image-marker/recipe';

package/lib/module/headless.js

@@ -0,0 +1,2 @@
+export * from './editor/headless.js';
+export { addWatermarkRecipeLayer, duplicateWatermarkRecipeLayer, groupWatermarkRecipeLayers, removeWatermarkRecipeLayer, reorderWatermarkRecipeLayer, ungroupWatermarkRecipeLayers, updateWatermarkRecipeLayer, } from '@image-marker/recipe';

package/lib/module/index.d.ts

@@ -0,0 +1,5 @@
+export { default } from './core/index.js';
+export * from './core/index.js';
+export { createWebMarker, Marker, WebMarker } from './core/web/index.js';
+export type * from './core/web/runtime.js';
+export type { WebResourceAdapter } from './core/web/browser.js';

package/lib/module/index.js

@@ -0,0 +1,3 @@
+export { default } from './core/index.js';
+export * from './core/index.js';
+export { createWebMarker, Marker, WebMarker } from './core/web/index.js';

package/lib/module/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/lib/source-manifest.json

@@ -0,0 +1,34 @@
+{
+  "description": "Generated from shared authoritative sources; editor/core-contract uses the Web Core binding.",
+  "sources": {
+    "packages/editor/src/adapter.ts": "530d2ad346f4c1be82a5eb632119cb43e46c8f67a6a0120c984b9214b1e86c67",
+    "packages/editor/src/controller.ts": "e097e11aa9297174707aa7eee089107aecabf66d9229f88a10ebae674e9d6781",
+    "packages/editor/src/core-contract.ts": "c56b2ce04daf5cbac5f531f4ad4b0bedfcce237e41a7eed59f14831f31db96b8",
+    "packages/editor/src/geometry.ts": "6fc09e7e586739ebc7e390da1260bdd85e7f0f35523584a44f1c2d1d1a10bf2d",
+    "packages/editor/src/headless.ts": "21704f8a9ed5af9b2414feb9d24f975b47e7b3746c6f39bd1575e7048c652470",
+    "packages/editor/src/presets.ts": "e680d7ec731e2525e6bcc09ad62630e16e9a84bf8c473d6fcfc8e87e60fc2002",
+    "packages/editor/src/projection.ts": "f2e0de309fe9acc061655f310defae38b746d87c675a6471574010b23f1455a1",
+    "packages/editor/src/types.ts": "7c311de43577555ac18305cac236f80c0090946f2714b1f5debabf1a25e82eb2",
+    "packages/web/src/editor-adapter.ts": "143fb98ca56936062574d0d1d2f00eba6928e67b6ae1dd73a0accae8de4d141e",
+    "packages/web/src/headless.ts": "4a1860a19eef496c2747dd2c32c18d1a6a9b9b29a242f16227793a9c750b7cdd",
+    "packages/web/src/index.ts": "be23ae2474a2d45d23dff60a09a214d209b43c01ca9680a3b79fdd37c557b1dc",
+    "src/batch.ts": "387c77b6bf25b3ab1989dd34540f60380453d13448a785585a094daeb86a4395",
+    "src/content-credentials.ts": "095cf78f92060cfc526e70bc8bde1acb044e4a975fc4b9a44dbd9251e8113b95",
+    "src/image-info.ts": "6083966af4f28153aff1b7305ef61ed3b1469aaefdc9aff712585833594b3777",
+    "src/index.ts": "0515a28b3b7bc86b6a3a9f742183be405b9382c6a79b790de73f271f6478a811",
+    "src/invisible-watermark.ts": "f00342e7c19b4af763eb666e2997bb7653ccb653d7996013b073e287236ebc87",
+    "src/job.ts": "7e88640d435734b51d17a9497db24b9870b96fa2b00f134f0bd4573304ca3a29",
+    "src/layout.ts": "08b1c72d595cb038ba14b31b2d47bbfb1ec28fa208ac4aee94e8f46bff2ce30c",
+    "src/marker.ts": "e6dea90ed0dac568e64716b56e076e4af68b55c85997719258fad19c6d919a29",
+    "src/recipe.ts": "930c6d7fc42eb83b2c4d3d4e220e9926c96f3999930fcb8c04b890c494564321",
+    "src/result.ts": "0c76a449979925c8c867fddb56ec784d2b67f4bf0d0a5121bd14c0eb2b707355",
+    "src/trace-runtime.ts": "d1e738cf0c1da5c34e914fbae01d1a1d99c2e8b5f1742e36bb9db94d0b48588c",
+    "src/validate.ts": "f42fc668ea19bd4c53e8a83aa2fecf842124166adb4bf88b0c393f856779a6a0",
+    "src/web/browser.ts": "336ee315b2b38fee7362d9dbd0d3ec8105f3519ede9e7d15b0855365d8c5ef9b",
+    "src/web/helpers.ts": "04fd36771ef9820fa8901a9f3f258f43d8f9dc80adae1e630c97aca691434b6c",
+    "src/web/index.ts": "e3f819f8c9a122358ce77f680a3a3fe6880d89bb8fff17c2f026270b7c7a7c28",
+    "src/web/invisible-worker-client.ts": "1e1d341306eeb35120c8e145594e0431f10b5d7f45a61d2d87573211af6e4b58",
+    "src/web/renderer.ts": "2d142c1aae0fd2fa5d4737560cf74ec644bc8f4fed1ed2f57896d178cc7967b7",
+    "src/web/runtime.ts": "0a3c87c0aab050331bc71e03d8babb627d85f1200ab45be14aca7c4f4b1e121d"
+  }
+}