mesurer-solid 0.1.0-beta.11

package/dist/context.d.ts

@@ -0,0 +1,359 @@
+export type MesurerContextRequest = {
+    scope?: "workspace";
+} | {
+    scope: "selection";
+} | {
+    annotation: string;
+};
+export type MesurerContextRect = {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+};
+export type MesurerContextEdges = {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+};
+export type MesurerElementFingerprint = {
+    tag: string;
+    id: string | null;
+    testId: string | null;
+    role: string | null;
+    ariaLabel: string | null;
+    classes: string[];
+    text: string | null;
+};
+export type MesurerElementInspection = {
+    selector: string;
+    tag: string;
+    id: string | null;
+    classes: string[];
+    text: string;
+    role: string | null;
+    ariaLabel: string | null;
+    rect: MesurerContextRect & {
+        right: number;
+        bottom: number;
+        x: number;
+        y: number;
+    };
+    margin: MesurerContextEdges;
+    padding: MesurerContextEdges;
+    border: MesurerContextEdges;
+    typography: {
+        fontFamily: string;
+        fontSize: string;
+        fontWeight: string;
+        lineHeight: string;
+        letterSpacing: string;
+        textAlign: string;
+        color: string;
+    };
+    appearance: {
+        backgroundColor: string;
+        borderColor: string;
+        borderRadius: string;
+        boxShadow: string;
+        opacity: string;
+    };
+    layout: {
+        display: string;
+        position: string;
+        zIndex: string;
+        overflowX: string;
+        overflowY: string;
+        flexDirection: string;
+        alignItems: string;
+        justifyContent: string;
+        gap: string;
+        gridTemplateColumns: string;
+        gridTemplateRows: string;
+        transform: string;
+    };
+    scroll: {
+        clientWidth: number;
+        clientHeight: number;
+        scrollWidth: number;
+        scrollHeight: number;
+        overflowsX: boolean;
+        overflowsY: boolean;
+    };
+};
+export type MesurerAnnotationTarget = {
+    id: string;
+    selector: string;
+    fingerprint: MesurerElementFingerprint;
+    lastRect: MesurerContextRect;
+};
+export type MesurerAnnotationBaseline = {
+    targets: Array<{
+        id: string;
+        selector: string;
+        rect: MesurerContextRect;
+    }>;
+    guides: Array<{
+        id: string;
+        orientation: "vertical" | "horizontal";
+        position: number;
+    }>;
+    measurements: Array<{
+        id: string;
+        rect: MesurerContextRect;
+        deltaX: number;
+        deltaY: number;
+        snapped?: boolean;
+    }>;
+    distances: Array<{
+        id: string;
+        rectA: MesurerContextRect;
+        rectB: MesurerContextRect;
+        horizontal: {
+            x1: number;
+            x2: number;
+            y: number;
+            value: number;
+        } | null;
+        vertical: {
+            y1: number;
+            y2: number;
+            x: number;
+            value: number;
+        } | null;
+    }>;
+};
+export type MesurerAnnotation = {
+    id: string;
+    note: string;
+    createdAt: number;
+    anchor: {
+        kind: "elements";
+        targets: MesurerAnnotationTarget[];
+        region: MesurerContextRect | null;
+    } | {
+        kind: "region";
+        rect: MesurerContextRect;
+    };
+    baseline: MesurerAnnotationBaseline;
+};
+export type MesurerContextTarget = {
+    ref: string;
+    inspection: MesurerElementInspection;
+};
+export type MesurerContextGuide = {
+    id: string;
+    orientation: "vertical" | "horizontal";
+    position: number;
+};
+export type MesurerContextMeasurement = {
+    id: string;
+    rect: MesurerContextRect;
+    deltaX: number;
+    deltaY: number;
+    snapped?: boolean;
+    targetRef?: string;
+};
+export type MesurerContextDistance = {
+    id: string;
+    rectA: MesurerContextRect;
+    rectB: MesurerContextRect;
+    horizontal: {
+        x1: number;
+        x2: number;
+        y: number;
+        value: number;
+    } | null;
+    vertical: {
+        y1: number;
+        y2: number;
+        x: number;
+        value: number;
+    } | null;
+    targetARef?: string;
+    targetBRef?: string;
+};
+export type MesurerContextV1 = {
+    schema: "mesurer.context/v1";
+    id: string;
+    createdAt: string;
+    scope: {
+        kind: "workspace";
+    } | {
+        kind: "selection";
+    } | {
+        kind: "annotation";
+        annotationId: string;
+        note: string;
+        targetStatus: "connected" | "partial" | "stale";
+    };
+    page: {
+        url: string;
+        title: string;
+    };
+    viewport: {
+        width: number;
+        height: number;
+        devicePixelRatio: number;
+        scrollX: number;
+        scrollY: number;
+    };
+    coordinateSpace: "viewport-css-px";
+    /** Requested/annotated viewport regions. Empty for whole-workspace context. */
+    regions: MesurerContextRect[];
+    visualState: {
+        rulersVisible: boolean;
+        xrayVisible: boolean;
+    };
+    targets: MesurerContextTarget[];
+    visualContext: {
+        guides: MesurerContextGuide[];
+        measurements: MesurerContextMeasurement[];
+        distances: MesurerContextDistance[];
+    };
+};
+export type MesurerReviewMetricChange = {
+    kind: "target-rect" | "guide" | "measurement" | "distance";
+    label: string;
+    before: number;
+    current: number;
+    delta: number;
+    unit: "px";
+};
+export type MesurerReviewPresenceChange = {
+    kind: "missing";
+    evidence: "target" | "guide" | "measurement" | "distance";
+    id: string;
+    label: string;
+};
+export type MesurerReviewChange = MesurerReviewMetricChange | MesurerReviewPresenceChange;
+export type MesurerReviewV1 = {
+    schema: "mesurer.review/v1";
+    annotationId: string;
+    note: string;
+    targetStatus: "connected" | "partial" | "stale";
+    baseline: MesurerAnnotationBaseline;
+    current: MesurerContextV1;
+    changes: MesurerReviewChange[];
+};
+export type MesurerCapturePlanV1 = {
+    schema: "mesurer.capture/v1";
+    contextId: string;
+    chrome: "hide";
+    evidence: "show";
+    captures: Array<{
+        id: "viewport";
+        kind: "viewport";
+    } | {
+        id: "focus";
+        kind: "clip";
+        rect: MesurerContextRect;
+    }>;
+};
+export type MesurerEvidenceImage = {
+    id: "viewport" | "focus" | string;
+    kind: "viewport" | "focus" | string;
+    mimeType: "image/png" | "image/jpeg" | string;
+    /** Base64 image bytes without a data URL prefix. */
+    data: string;
+};
+export type MesurerEvidenceProvider = (input: {
+    context: MesurerContextV1;
+    plan: MesurerCapturePlanV1;
+}) => Promise<MesurerEvidenceImage[]>;
+export type MesurerContextDelivery = {
+    context: MesurerContextV1;
+    text: string;
+    images: MesurerEvidenceImage[];
+};
+export type MesurerContextSender = (delivery: MesurerContextDelivery) => Promise<void>;
+export type AcpTextContentBlock = {
+    type: "text";
+    text: string;
+};
+export type AcpImageContentBlock = {
+    type: "image";
+    mimeType: string;
+    data: string;
+};
+export type MesurerAcpContentBlock = AcpTextContentBlock | AcpImageContentBlock;
+/**
+ * Explicit renderer-to-protocol adapter source. The renderer owns live DOM references;
+ * this public boundary deliberately describes only the fields that may enter JSON context.
+ */
+export type MesurerWorkspaceContextSource = {
+    snapshot(): {
+        rulersVisible: boolean;
+        xrayVisible: boolean;
+        guideRelevanceTolerance?: number;
+        measurements: Array<{
+            id: string;
+            rect: MesurerContextRect;
+            deltaX: number;
+            deltaY: number;
+            snapped?: boolean;
+            elementRef?: HTMLElement | null;
+        }>;
+        activeMeasurement: {
+            id: string;
+            rect: MesurerContextRect;
+            deltaX: number;
+            deltaY: number;
+            snapped?: boolean;
+            elementRef?: HTMLElement | null;
+        } | null;
+        heldDistances: Array<{
+            id: string;
+            rectA: MesurerContextRect;
+            rectB: MesurerContextRect;
+            elementRefA?: HTMLElement | null;
+            elementRefB?: HTMLElement | null;
+            horizontal: {
+                x1: number;
+                x2: number;
+                y: number;
+                value: number;
+            } | null;
+            vertical: {
+                y1: number;
+                y2: number;
+                x: number;
+                value: number;
+            } | null;
+        }>;
+        guides: Array<{
+            id: string;
+            orientation: "vertical" | "horizontal";
+            position: number;
+        }>;
+    } | null;
+    currentSelection(): {
+        elements: HTMLElement[];
+        region: MesurerContextRect | null;
+    };
+    annotations(): MesurerAnnotation[];
+    annotation(id: string): (MesurerAnnotation & {
+        resolvedTargets: Array<{
+            target: MesurerAnnotationTarget;
+            element: HTMLElement | null;
+        }>;
+    }) | null;
+    annotationRect(id: string): MesurerContextRect | null;
+};
+export declare function captureMesurerContext(options: {
+    runtime: MesurerWorkspaceContextSource;
+    ownerDocument: Document;
+    ownerWindow: Window;
+    request?: MesurerContextRequest;
+}): MesurerContextV1;
+export declare function formatMesurerContext(context: MesurerContextV1): string;
+export declare function createMesurerCapturePlan(context: MesurerContextV1): MesurerCapturePlanV1;
+export declare function reviewMesurerAnnotation(options: {
+    runtime: MesurerWorkspaceContextSource;
+    ownerDocument: Document;
+    ownerWindow: Window;
+    annotationId: string;
+}): MesurerReviewV1;
+export declare function toAcpContentBlocks(context: MesurerContextV1, images?: MesurerEvidenceImage[]): MesurerAcpContentBlock[];
+export declare function copyTextToClipboard(ownerDocument: Document, ownerWindow: Window, text: string): Promise<void>;

package/dist/core.d.ts

@@ -0,0 +1,147 @@
+export type Registration = {
+    readonly dispose: () => void;
+};
+export type PluginId = string;
+export type PluginStateSnapshot = Record<string, unknown>;
+export type PluginStateScope = "all" | "history" | "persist";
+export type ToolContribution = {
+    id: string;
+    label: string;
+    shortcut?: string;
+    command: string;
+    order?: number;
+    builtin?: string;
+    icon?: {
+        viewBox?: string;
+        paths: string[];
+    };
+    active?: () => boolean;
+    disabled?: () => boolean;
+};
+export type SettingsContribution = {
+    id: string;
+    label: string;
+    order?: number;
+    builtin?: string;
+};
+export type OverlayContribution = {
+    id: string;
+    order?: number;
+    builtin?: string;
+};
+export type CommandHandler = (args: unknown, context: {
+    source?: unknown;
+}) => void | Promise<void>;
+export type HookHandler = (event: unknown) => void | Promise<void>;
+export type StateSliceDefinition<T = unknown> = {
+    id: string;
+    initial: T;
+    history?: boolean;
+    persist?: boolean;
+};
+export type MesurerPluginContext = {
+    state: {
+        register<T>(definition: StateSliceDefinition<T>): Registration;
+        get<T>(id: string): T | undefined;
+        update<T>(id: string, update: (value: T) => T): void;
+    };
+    tool: {
+        register(contribution: ToolContribution): Registration;
+    };
+    settings: {
+        register(contribution: SettingsContribution): Registration;
+    };
+    overlay: {
+        register(contribution: OverlayContribution): Registration;
+    };
+    command: {
+        register(id: string, handler: CommandHandler): Registration;
+        execute(id: string, args?: unknown, source?: unknown): Promise<void>;
+    };
+    hook: {
+        on(name: string, handler: HookHandler): Registration;
+        emit(name: string, event: unknown): Promise<void>;
+    };
+    service: {
+        provide<T>(id: string, value: T): Registration;
+        get<T>(id: string): T | undefined;
+    };
+    lifecycle: {
+        onDispose(handler: () => void): Registration;
+    };
+};
+export type MesurerPlugin = {
+    id: PluginId;
+    version?: string;
+    requires?: string[];
+    provides?: string[];
+    setup(context: MesurerPluginContext): void | Promise<void>;
+};
+export type MesurerPluginDescription = {
+    plugins: Array<{
+        id: string;
+        version?: string;
+        requires: string[];
+        provides: string[];
+    }>;
+    tools: Array<{
+        id: string;
+        label: string;
+        shortcut?: string;
+        command: string;
+        order?: number;
+        builtin?: string;
+    }>;
+    settings: SettingsContribution[];
+    overlays: OverlayContribution[];
+    state: Array<{
+        id: string;
+        history: boolean;
+        persist: boolean;
+    }>;
+    commands: string[];
+    hooks: string[];
+    services: string[];
+};
+export type MesurerPluginChange = {
+    pluginId?: string;
+    reason: "load" | "remove" | "replace" | "registration" | "state" | "history";
+};
+export type MesurerPluginHost = {
+    load(plugin: MesurerPlugin): Promise<void>;
+    remove(id: string): boolean;
+    replace(plugin: MesurerPlugin): Promise<void>;
+    has(id: string): boolean;
+    plugin(id: string): MesurerPlugin | undefined;
+    listPlugins(): MesurerPlugin[];
+    tools(): ToolContribution[];
+    settings(): SettingsContribution[];
+    overlays(): OverlayContribution[];
+    state: {
+        get<T>(id: string): T | undefined;
+        update<T>(id: string, update: (value: T) => T): void;
+        serialize(scope?: PluginStateScope): PluginStateSnapshot;
+        restore(snapshot: PluginStateSnapshot, scope?: PluginStateScope): void;
+    };
+    service: {
+        get<T>(id: string): T | undefined;
+    };
+    command: {
+        execute(id: string, args?: unknown, source?: unknown): Promise<void>;
+    };
+    hook: {
+        emit(name: string, event: unknown): Promise<void>;
+    };
+    undo(): boolean;
+    redo(): boolean;
+    canUndo(): boolean;
+    canRedo(): boolean;
+    subscribe(listener: (event: MesurerPluginChange) => void): () => void;
+    describe(): MesurerPluginDescription;
+    dispose(): void;
+};
+export declare const defineMesurerPlugin: <T extends MesurerPlugin>(plugin: T) => T;
+export declare const createMesurerPluginHost: () => MesurerPluginHost;
+export declare function createMesurerRuntime(options?: {
+    plugins?: MesurerPlugin[];
+}): Promise<MesurerPluginHost>;