nudge-ui 0.2.0 → 0.2.2

package/dist/inspector/sketch/handoff.js

@@ -0,0 +1,72 @@
+import { useSyncExternalStore } from "react";
+import { blobToBase64 } from "./raster.js";
+import { toAgentSketchMetadata } from "./model.js";
+const EMPTY_HANDOFF = null;
+let handoffSnapshot = EMPTY_HANDOFF;
+const listeners = new Set();
+function notify() {
+    for (const listener of listeners) {
+        try {
+            listener();
+        }
+        catch {
+            // A handoff view must not prevent other subscribers from updating.
+        }
+    }
+}
+function randomId() {
+    try {
+        if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function")
+            return crypto.randomUUID();
+    }
+    catch {
+        // Use the fallback below.
+    }
+    return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
+}
+export function createSketchHandoffSnapshot(items) {
+    if (items.length === 0)
+        return null;
+    return {
+        localBatchId: randomId(),
+        entries: items.map((item) => ({
+            id: item.document.id,
+            revision: item.document.revision,
+            metadata: toAgentSketchMetadata(item.document),
+            annotatedImage: item.document.annotatedImage,
+        })),
+    };
+}
+export function createSketchAttachments(handoff) {
+    return Promise.all(handoff.entries.map(async (entry) => ({
+        ...entry.metadata,
+        data: await blobToBase64(entry.annotatedImage),
+    })));
+}
+export function sketchMetadataForHandoff(handoff) {
+    return handoff?.entries.map((entry) => entry.metadata) ?? [];
+}
+export function getSketchClipboardHandoffSnapshot() {
+    return handoffSnapshot;
+}
+export function subscribeSketchClipboardHandoff(listener) {
+    listeners.add(listener);
+    return () => listeners.delete(listener);
+}
+export function useSketchClipboardHandoff() {
+    return useSyncExternalStore(subscribeSketchClipboardHandoff, getSketchClipboardHandoffSnapshot, getSketchClipboardHandoffSnapshot);
+}
+export function recordSketchClipboardHandoff(snapshot) {
+    handoffSnapshot = snapshot;
+    notify();
+}
+export function clearSketchClipboardHandoff() {
+    if (handoffSnapshot === null)
+        return;
+    handoffSnapshot = null;
+    notify();
+}
+export function resetSketchClipboardHandoff() {
+    handoffSnapshot = null;
+    notify();
+}

package/dist/inspector/sketch/interaction.d.ts

@@ -0,0 +1,21 @@
+import { type CapturedSketch } from "./capture.js";
+export type SketchCaptureState = "idle" | "sketching" | "capturing" | "ready" | "error";
+export type SketchEntryTool = "pen" | "annotate";
+export interface SketchInteractionSnapshot {
+    readonly captureState: SketchCaptureState;
+    readonly captured: CapturedSketch | null;
+    readonly editingId: string | null;
+    readonly error: string | null;
+    readonly initialTool: SketchEntryTool;
+}
+export declare function getSketchInteractionSnapshot(): SketchInteractionSnapshot;
+export declare function subscribeSketchInteraction(listener: () => void): () => void;
+export declare function useSketchInteraction(): SketchInteractionSnapshot;
+export declare function isSketchInteractionActive(): boolean;
+export declare function useSketchInteractionActive(): boolean;
+export declare function beginSketchCapture(initialTool?: SketchEntryTool): void;
+export declare function completeSketchCapture(hostElement: HTMLElement): Promise<CapturedSketch>;
+export declare function cancelSketchInteraction(): void;
+export declare function openSketchEditor(sketchId: string): void;
+export declare function closeSketchEditor(): void;
+export declare function resetSketchInteraction(): void;

package/dist/inspector/sketch/interaction.js

@@ -0,0 +1,98 @@
+import { useSyncExternalStore } from "react";
+import { captureViewport, } from "./capture.js";
+const EMPTY_SNAPSHOT = {
+    captureState: "idle",
+    captured: null,
+    editingId: null,
+    error: null,
+    initialTool: "pen",
+};
+let snapshot = EMPTY_SNAPSHOT;
+let captureController = null;
+const listeners = new Set();
+function publish(next) {
+    snapshot = next;
+    for (const listener of listeners) {
+        try {
+            listener();
+        }
+        catch {
+            // A view subscriber must not break the interaction state machine.
+        }
+    }
+}
+export function getSketchInteractionSnapshot() {
+    return snapshot;
+}
+export function subscribeSketchInteraction(listener) {
+    listeners.add(listener);
+    return () => listeners.delete(listener);
+}
+export function useSketchInteraction() {
+    return useSyncExternalStore(subscribeSketchInteraction, getSketchInteractionSnapshot, getSketchInteractionSnapshot);
+}
+export function isSketchInteractionActive() {
+    return snapshot.captureState !== "idle" || snapshot.captured !== null || snapshot.editingId !== null;
+}
+export function useSketchInteractionActive() {
+    const current = useSketchInteraction();
+    return current.captureState !== "idle" || current.captured !== null || current.editingId !== null;
+}
+export function beginSketchCapture(initialTool = "pen") {
+    captureController?.abort();
+    captureController = null;
+    publish({ captureState: "sketching", captured: null, editingId: null, error: null, initialTool });
+}
+export function completeSketchCapture(hostElement) {
+    captureController?.abort();
+    const controller = new AbortController();
+    captureController = controller;
+    const initialTool = snapshot.initialTool;
+    publish({ captureState: "capturing", captured: null, editingId: null, error: null, initialTool });
+    const options = { hostElement, signal: controller.signal };
+    return captureViewport(options)
+        .then((captured) => {
+        if (captureController !== controller)
+            return captured;
+        captureController = null;
+        publish({ captureState: "ready", captured, editingId: null, error: null, initialTool });
+        return captured;
+    })
+        .catch((error) => {
+        if (captureController !== controller)
+            throw error;
+        captureController = null;
+        if (controller.signal.aborted) {
+            publish(EMPTY_SNAPSHOT);
+            throw error;
+        }
+        publish({
+            captureState: "error",
+            captured: null,
+            editingId: null,
+            error: error instanceof Error ? error.message : "The viewport could not be captured.",
+            initialTool,
+        });
+        throw error;
+    });
+}
+export function cancelSketchInteraction() {
+    captureController?.abort();
+    captureController = null;
+    publish(EMPTY_SNAPSHOT);
+}
+export function openSketchEditor(sketchId) {
+    captureController?.abort();
+    captureController = null;
+    publish({ captureState: "idle", captured: null, editingId: sketchId, error: null, initialTool: "pen" });
+}
+export function closeSketchEditor() {
+    if (snapshot.captureState !== "ready" && snapshot.editingId === null)
+        return;
+    publish(EMPTY_SNAPSHOT);
+}
+export function resetSketchInteraction() {
+    captureController?.abort();
+    captureController = null;
+    snapshot = EMPTY_SNAPSHOT;
+}

package/dist/inspector/sketch/model.d.ts

@@ -0,0 +1,104 @@
+import type { AgentSketchCaptureMetadata, AgentSketchMetadata } from "../agent/protocol.js";
+export declare const SKETCH_SCHEMA_VERSION: 1;
+export declare const SKETCH_DATABASE_NAME = "nudge-ui-sketches";
+export declare const SKETCH_DATABASE_VERSION = 1;
+export declare const SKETCH_DOCUMENTS_STORE = "documents";
+export declare const SKETCH_HANDOFFS_STORE = "handoffs";
+export declare const SKETCH_LIMITS: {
+    readonly completedSketches: 4;
+    readonly imageEdge: 2048;
+    readonly imageBytes: number;
+    readonly projectBytes: number;
+    readonly strokes: 500;
+    readonly points: 20000;
+    readonly annotations: 50;
+    readonly description: 2000;
+    readonly url: 2048;
+    readonly title: 512;
+};
+export declare const SKETCH_STROKE_WIDTH = 6;
+export declare const SKETCH_STROKE_COLOR = "#0096ff";
+export declare const SKETCH_STROKE_OUTLINE = "";
+export declare const SKETCH_ANNOTATION_RADIUS = 16;
+declare const LEGACY_SKETCH_STROKE_COLOR = "#ef4444";
+declare const LEGACY_SKETCH_STROKE_OUTLINE = "#111827";
+export type SketchStatus = "pending" | "dispatching" | "handing-off" | "needs-review" | "unknown";
+export type SketchTransport = "local" | "clipboard" | "direct";
+export type SketchHandoffState = SketchStatus;
+export interface SketchPoint {
+    readonly x: number;
+    readonly y: number;
+}
+type SketchStrokeColor = typeof SKETCH_STROKE_COLOR | typeof LEGACY_SKETCH_STROKE_COLOR;
+type SketchStrokeOutline = typeof SKETCH_STROKE_OUTLINE | typeof LEGACY_SKETCH_STROKE_OUTLINE;
+export type SketchStrokeKind = "freehand" | "rectangle";
+export interface SketchStroke {
+    readonly id: string;
+    /** Optional for compatibility with strokes saved before movable layers. */
+    readonly kind?: SketchStrokeKind;
+    readonly width: number;
+    readonly color: SketchStrokeColor;
+    readonly outlineColor: SketchStrokeOutline;
+    readonly points: readonly SketchPoint[];
+}
+export interface SketchAnnotation {
+    readonly id: string;
+    readonly number: number;
+    readonly point: SketchPoint;
+    readonly description: string;
+}
+export interface SketchCaptureMetadata extends AgentSketchCaptureMetadata {
+    readonly imageWidth: number;
+    readonly imageHeight: number;
+}
+export interface SketchDocument {
+    readonly schemaVersion: typeof SKETCH_SCHEMA_VERSION;
+    readonly projectId: string;
+    readonly id: string;
+    readonly revision: number;
+    readonly createdAt: number;
+    readonly updatedAt: number;
+    readonly capture: SketchCaptureMetadata;
+    readonly description: string;
+    readonly strokes: readonly SketchStroke[];
+    /** Optional for compatibility with sketches saved before annotations existed. */
+    readonly annotations?: readonly SketchAnnotation[];
+    readonly imageWidth: number;
+    readonly imageHeight: number;
+    readonly originalByteSize: number;
+    readonly annotatedByteSize: number;
+    readonly filename: string;
+    readonly originalImage: Blob;
+    readonly annotatedImage: Blob;
+}
+export interface SketchHandoffRecord {
+    readonly id: string;
+    readonly projectId: string;
+    readonly sketchId: string;
+    readonly sketchRevision: number;
+    readonly localBatchId: string;
+    readonly batchRevision?: number;
+    readonly transport: SketchTransport;
+    readonly agentRequestId?: string;
+    readonly timestamp: number;
+    readonly state: SketchHandoffState;
+}
+export interface SketchQueueItem {
+    readonly document: SketchDocument;
+    readonly handoff: SketchHandoffRecord | null;
+    readonly status: SketchStatus;
+}
+export declare function createSketchFilename(id: string, revision: number): string;
+export declare function isFiniteNumber(value: unknown): value is number;
+export declare function isSketchCaptureMetadata(value: unknown): value is SketchCaptureMetadata;
+export declare function isSketchPoint(value: unknown): value is SketchPoint;
+export declare function isSketchAnnotation(value: unknown): value is SketchAnnotation;
+export declare function isSketchStroke(value: unknown): value is SketchStroke;
+export declare function isSketchDocument(value: unknown): value is SketchDocument;
+export declare function isSketchHandoffRecord(value: unknown): value is SketchHandoffRecord;
+export declare function cloneSketchDocument(document: SketchDocument): SketchDocument;
+export declare function cloneSketchHandoff(handoff: SketchHandoffRecord): SketchHandoffRecord;
+export declare function sketchContentFingerprint(description: string, strokes: readonly SketchStroke[], annotations?: readonly SketchAnnotation[]): string;
+export declare function sameSketchContent(document: Pick<SketchDocument, "description" | "strokes" | "annotations">, description: string, strokes: readonly SketchStroke[], annotations?: readonly SketchAnnotation[]): boolean;
+export declare function toAgentSketchMetadata(document: SketchDocument): AgentSketchMetadata;
+export {};

package/dist/inspector/sketch/model.js

@@ -0,0 +1,282 @@
+export const SKETCH_SCHEMA_VERSION = 1;
+export const SKETCH_DATABASE_NAME = "nudge-ui-sketches";
+export const SKETCH_DATABASE_VERSION = 1;
+export const SKETCH_DOCUMENTS_STORE = "documents";
+export const SKETCH_HANDOFFS_STORE = "handoffs";
+export const SKETCH_LIMITS = {
+    completedSketches: 4,
+    imageEdge: 2_048,
+    imageBytes: 2 * 1024 * 1024,
+    projectBytes: 20 * 1024 * 1024,
+    strokes: 500,
+    points: 20_000,
+    annotations: 50,
+    description: 2_000,
+    url: 2_048,
+    title: 512,
+};
+export const SKETCH_STROKE_WIDTH = 6;
+export const SKETCH_STROKE_COLOR = "#0096ff";
+export const SKETCH_STROKE_OUTLINE = "";
+export const SKETCH_ANNOTATION_RADIUS = 16;
+// Keep accepting sketches saved before the annotation color update. Existing
+// PNGs remain unchanged until a user edits and saves them again.
+const LEGACY_SKETCH_STROKE_COLOR = "#ef4444";
+const LEGACY_SKETCH_STROKE_OUTLINE = "#111827";
+export function createSketchFilename(id, revision) {
+    return `sketch-${id}-r${revision}.png`;
+}
+export function isFiniteNumber(value) {
+    return typeof value === "number" && Number.isFinite(value);
+}
+function boundedString(value, maximum, allowEmpty = false) {
+    return typeof value === "string" && value.length <= maximum && (allowEmpty || value.length > 0);
+}
+function isBlob(value, mimeType) {
+    return typeof Blob !== "undefined"
+        && value instanceof Blob
+        && (mimeType === undefined || value.type === mimeType);
+}
+function validHttpUrl(value, maximum) {
+    if (!boundedString(value, maximum))
+        return false;
+    try {
+        const url = new URL(value);
+        return url.protocol === "http:" || url.protocol === "https:";
+    }
+    catch {
+        return false;
+    }
+}
+export function isSketchCaptureMetadata(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const capture = value;
+    const keys = [
+        "url",
+        "title",
+        "timestamp",
+        "viewportWidth",
+        "viewportHeight",
+        "scrollX",
+        "scrollY",
+        "devicePixelRatio",
+        "host",
+        "framework",
+        "imageWidth",
+        "imageHeight",
+    ];
+    if (!Object.keys(capture).every((key) => keys.includes(key)))
+        return false;
+    return validHttpUrl(capture.url, SKETCH_LIMITS.url)
+        && boundedString(capture.title, SKETCH_LIMITS.title, true)
+        && Number.isSafeInteger(capture.timestamp)
+        && capture.timestamp > 0
+        && Number.isSafeInteger(capture.viewportWidth)
+        && capture.viewportWidth > 0
+        && capture.viewportWidth <= 100_000
+        && Number.isSafeInteger(capture.viewportHeight)
+        && capture.viewportHeight > 0
+        && capture.viewportHeight <= 100_000
+        && isFiniteNumber(capture.scrollX)
+        && capture.scrollX >= 0
+        && isFiniteNumber(capture.scrollY)
+        && capture.scrollY >= 0
+        && isFiniteNumber(capture.devicePixelRatio)
+        && capture.devicePixelRatio > 0
+        && capture.devicePixelRatio <= 100
+        && boundedString(capture.host, 128)
+        && boundedString(capture.framework, 128)
+        && Number.isSafeInteger(capture.imageWidth)
+        && capture.imageWidth > 0
+        && capture.imageWidth <= SKETCH_LIMITS.imageEdge
+        && Number.isSafeInteger(capture.imageHeight)
+        && capture.imageHeight > 0
+        && capture.imageHeight <= SKETCH_LIMITS.imageEdge;
+}
+export function isSketchPoint(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const point = value;
+    return Object.keys(point).every((key) => key === "x" || key === "y")
+        && isFiniteNumber(point.x)
+        && isFiniteNumber(point.y)
+        && point.x >= 0
+        && point.x <= SKETCH_LIMITS.imageEdge
+        && point.y >= 0
+        && point.y <= SKETCH_LIMITS.imageEdge;
+}
+export function isSketchAnnotation(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const annotation = value;
+    return Object.keys(annotation).every((key) => ["id", "number", "point", "description"].includes(key))
+        && boundedString(annotation.id, 256)
+        && Number.isSafeInteger(annotation.number)
+        && annotation.number >= 1
+        && annotation.number <= SKETCH_LIMITS.annotations
+        && isSketchPoint(annotation.point)
+        && boundedString(annotation.description, SKETCH_LIMITS.description);
+}
+export function isSketchStroke(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const stroke = value;
+    return Object.keys(stroke).every((key) => ["id", "kind", "width", "color", "outlineColor", "points"].includes(key))
+        && boundedString(stroke.id, 256)
+        && (stroke.kind === undefined || stroke.kind === "freehand" || stroke.kind === "rectangle")
+        && isFiniteNumber(stroke.width)
+        && stroke.width > 0
+        && stroke.width <= 128
+        && (stroke.color === SKETCH_STROKE_COLOR || stroke.color === LEGACY_SKETCH_STROKE_COLOR)
+        && (stroke.outlineColor === SKETCH_STROKE_OUTLINE || stroke.outlineColor === LEGACY_SKETCH_STROKE_OUTLINE)
+        && Array.isArray(stroke.points)
+        && stroke.points.length > 0
+        && stroke.points.length <= SKETCH_LIMITS.points
+        && stroke.points.every(isSketchPoint);
+}
+export function isSketchDocument(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const document = value;
+    return Object.keys(document).every((key) => [
+        "schemaVersion",
+        "projectId",
+        "id",
+        "revision",
+        "createdAt",
+        "updatedAt",
+        "capture",
+        "description",
+        "strokes",
+        "annotations",
+        "imageWidth",
+        "imageHeight",
+        "originalByteSize",
+        "annotatedByteSize",
+        "filename",
+        "originalImage",
+        "annotatedImage",
+    ].includes(key))
+        && document.schemaVersion === SKETCH_SCHEMA_VERSION
+        && boundedString(document.projectId, 256)
+        && boundedString(document.id, 256)
+        && Number.isSafeInteger(document.revision)
+        && document.revision > 0
+        && Number.isSafeInteger(document.createdAt)
+        && Number.isSafeInteger(document.updatedAt)
+        && isSketchCaptureMetadata(document.capture)
+        && boundedString(document.description, SKETCH_LIMITS.description, true)
+        && Array.isArray(document.strokes)
+        && document.strokes.length <= SKETCH_LIMITS.strokes
+        && document.strokes.every(isSketchStroke)
+        && document.strokes.reduce((total, stroke) => total + stroke.points.length, 0) <= SKETCH_LIMITS.points
+        && (document.annotations === undefined
+            || (Array.isArray(document.annotations)
+                && document.annotations.length <= SKETCH_LIMITS.annotations
+                && document.annotations.every(isSketchAnnotation)
+                && new Set(document.annotations.map((annotation) => annotation.number)).size === document.annotations.length))
+        && document.imageWidth === document.capture.imageWidth
+        && document.imageHeight === document.capture.imageHeight
+        && Number.isSafeInteger(document.originalByteSize)
+        && document.originalByteSize > 0
+        && document.originalByteSize <= SKETCH_LIMITS.imageBytes
+        && Number.isSafeInteger(document.annotatedByteSize)
+        && document.annotatedByteSize > 0
+        && document.annotatedByteSize <= SKETCH_LIMITS.imageBytes
+        && boundedString(document.filename, 256)
+        && isBlob(document.originalImage, "image/png")
+        && isBlob(document.annotatedImage, "image/png")
+        && document.originalImage.size === document.originalByteSize
+        && document.annotatedImage.size === document.annotatedByteSize;
+}
+export function isSketchHandoffRecord(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const handoff = value;
+    return Object.keys(handoff).every((key) => [
+        "id",
+        "projectId",
+        "sketchId",
+        "sketchRevision",
+        "localBatchId",
+        "batchRevision",
+        "transport",
+        "agentRequestId",
+        "timestamp",
+        "state",
+    ].includes(key))
+        && boundedString(handoff.id, 256)
+        && boundedString(handoff.projectId, 256)
+        && boundedString(handoff.sketchId, 256)
+        && Number.isSafeInteger(handoff.sketchRevision)
+        && handoff.sketchRevision > 0
+        && boundedString(handoff.localBatchId, 256)
+        && (handoff.batchRevision === undefined
+            || (Number.isSafeInteger(handoff.batchRevision) && handoff.batchRevision >= 0))
+        && (handoff.transport === "local" || handoff.transport === "clipboard" || handoff.transport === "direct")
+        && (handoff.agentRequestId === undefined || boundedString(handoff.agentRequestId, 256))
+        && Number.isSafeInteger(handoff.timestamp)
+        && (handoff.state === "pending"
+            || handoff.state === "dispatching"
+            || handoff.state === "handing-off"
+            || handoff.state === "needs-review"
+            || handoff.state === "unknown");
+}
+export function cloneSketchDocument(document) {
+    return {
+        ...document,
+        capture: { ...document.capture },
+        strokes: document.strokes.map((stroke) => ({
+            ...stroke,
+            points: stroke.points.map((point) => ({ ...point })),
+        })),
+        ...(document.annotations
+            ? {
+                annotations: document.annotations.map((annotation) => ({
+                    ...annotation,
+                    point: { ...annotation.point },
+                })),
+            }
+            : {}),
+    };
+}
+export function cloneSketchHandoff(handoff) {
+    return { ...handoff };
+}
+export function sketchContentFingerprint(description, strokes, annotations = []) {
+    return JSON.stringify({ description, strokes, annotations });
+}
+export function sameSketchContent(document, description, strokes, annotations = []) {
+    return sketchContentFingerprint(document.description, document.strokes, document.annotations ?? [])
+        === sketchContentFingerprint(description, strokes, annotations);
+}
+export function toAgentSketchMetadata(document) {
+    const annotations = document.annotations?.map((annotation) => ({
+        number: annotation.number,
+        description: annotation.description,
+    }));
+    return {
+        id: document.id,
+        revision: document.revision,
+        filename: document.filename,
+        mimeType: "image/png",
+        width: document.imageWidth,
+        height: document.imageHeight,
+        byteSize: document.annotatedByteSize,
+        capture: {
+            url: document.capture.url,
+            title: document.capture.title,
+            timestamp: document.capture.timestamp,
+            viewportWidth: document.capture.viewportWidth,
+            viewportHeight: document.capture.viewportHeight,
+            scrollX: document.capture.scrollX,
+            scrollY: document.capture.scrollY,
+            devicePixelRatio: document.capture.devicePixelRatio,
+            host: document.capture.host,
+            framework: document.capture.framework,
+        },
+        ...(document.description ? { description: document.description } : {}),
+        ...(annotations?.length ? { annotations } : {}),
+    };
+}

package/dist/inspector/sketch/persistence.d.ts

@@ -0,0 +1,21 @@
+import { type SketchDocument, type SketchHandoffRecord } from "./model.js";
+export declare class SketchStorageError extends Error {
+    readonly code = "sketch_storage_error";
+    constructor(message: string, options?: {
+        cause?: unknown;
+    });
+}
+export interface SketchPersistenceSnapshot {
+    readonly documents: SketchDocument[];
+    readonly handoffs: SketchHandoffRecord[];
+}
+export declare function readSketchPersistence(projectId: string): Promise<SketchPersistenceSnapshot>;
+/** Writes a document and its initial/current handoff atomically. */
+export declare function writeSketchPersistence(projectId: string, document: SketchDocument, handoff: SketchHandoffRecord): Promise<void>;
+export declare function writeSketchHandoff(projectId: string, handoff: SketchHandoffRecord): Promise<void>;
+export declare function writeSketchHandoffs(projectId: string, handoffs: readonly SketchHandoffRecord[]): Promise<void>;
+export declare function deleteSketchPersistence(projectId: string, sketchId: string): Promise<void>;
+export declare function clearSketchPersistence(projectId: string): Promise<void>;
+export declare function closeSketchDatabase(): Promise<void>;
+/** Test seam for the no-IndexedDB fallback; it does not delete browser data. */
+export declare function resetSketchMemory(): void;