@you-agent-factory/client 0.0.0 → 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export { type components, FACTORY_EVENT_SCHEMA_VERSIONS, FACTORY_EVENT_TYPES, type FactoryDefinition, type FactoryEvent, type FactoryEventType, type operations, type paths, } from "./contracts.js";
+export { compareFactoryEvents, createFactoryEventCursor, type FactoryEventCursor, getFactoryEventEffectiveSequence, orderFactoryEvents, } from "./event-ordering.js";
+export { FACTORY_RECORDING_SCHEMA_VERSION, type FactoryRecording, FactoryRecordingValidationError, parseFactoryRecording, type RecordingValidationIssue, type RecordingValidationIssueCode, type SafeParseFactoryRecordingResult, safeParseFactoryRecording, } from "./recording.js";
+export { type FactoryReplayTextIssue, type FactoryReplayTextIssueCode, FactoryReplayTextParseError, parseFactoryEventReplayText, type SafeParseFactoryEventReplayTextResult, safeParseFactoryEventReplayText, } from "./replay.js";
+export { parseFactoryVisualizationLayout, safeParseFactoryVisualizationLayout, type FactoryVisualizationLayoutCanonicalNodeContext, } from "./visualization-layout.js";
+export { FACTORY_VISUALIZATION_LAYOUT_SCHEMA_VERSION, type FactoryVisualizationAnnotation, type FactoryVisualizationEmbeddedImageSource, type FactoryVisualizationImageAnnotation, type FactoryVisualizationImageContent, type FactoryVisualizationLayoutIssue, type FactoryVisualizationLayoutIssueCode, type FactoryVisualizationLayoutV1, type FactoryVisualizationNodeEmptyState, type FactoryVisualizationNoteAnnotation, type FactoryVisualizationNoteTone, type FactoryVisualizationPosition, type FactoryVisualizationSize, type FactoryVisualizationTextEmptyState, type SafeParseFactoryVisualizationLayoutResult, } from "./visualization-layout-contracts.js";
+export { FactoryVisualizationLayoutValidationError } from "./visualization-layout-error.js";
+export { MAX_EMBEDDED_IMAGE_BYTES, MAX_IMAGE_ALT_TEXT_LENGTH, MAX_LAYOUT_IMAGE_BYTES, } from "./visualization-layout-media.js";

package/dist/index.js

@@ -0,0 +1,8 @@
+export { FACTORY_EVENT_SCHEMA_VERSIONS, FACTORY_EVENT_TYPES, } from "./contracts.js";
+export { compareFactoryEvents, createFactoryEventCursor, getFactoryEventEffectiveSequence, orderFactoryEvents, } from "./event-ordering.js";
+export { FACTORY_RECORDING_SCHEMA_VERSION, FactoryRecordingValidationError, parseFactoryRecording, safeParseFactoryRecording, } from "./recording.js";
+export { FactoryReplayTextParseError, parseFactoryEventReplayText, safeParseFactoryEventReplayText, } from "./replay.js";
+export { parseFactoryVisualizationLayout, safeParseFactoryVisualizationLayout, } from "./visualization-layout.js";
+export { FACTORY_VISUALIZATION_LAYOUT_SCHEMA_VERSION, } from "./visualization-layout-contracts.js";
+export { FactoryVisualizationLayoutValidationError } from "./visualization-layout-error.js";
+export { MAX_EMBEDDED_IMAGE_BYTES, MAX_IMAGE_ALT_TEXT_LENGTH, MAX_LAYOUT_IMAGE_BYTES, } from "./visualization-layout-media.js";

package/dist/recording.d.ts

@@ -0,0 +1,34 @@
+import { type FactoryDefinition, type FactoryEvent } from "./contracts.js";
+export declare const FACTORY_RECORDING_SCHEMA_VERSION: "factory-recording/v1";
+export interface FactoryRecording {
+    schemaVersion: typeof FACTORY_RECORDING_SCHEMA_VERSION;
+    id: string;
+    title: string;
+    summary?: string;
+    factory?: FactoryDefinition;
+    events: FactoryEvent[];
+}
+export type RecordingValidationIssueCode = "invalid_type" | "invalid_value" | "missing_required_field" | "unsupported_field" | "unsupported_recording_schema_version" | "unsupported_event_type" | "unsupported_event_schema_version" | "duplicate_event_id" | "mixed_factory_session_identity" | "missing_topology_bootstrap";
+export interface RecordingValidationIssue {
+    category: "structure" | "semantic";
+    code: RecordingValidationIssueCode;
+    path: readonly (string | number)[];
+    message: string;
+}
+export type SafeParseFactoryRecordingResult = {
+    success: true;
+    data: FactoryRecording;
+} | {
+    success: false;
+    issues: readonly RecordingValidationIssue[];
+};
+export declare class FactoryRecordingValidationError extends Error {
+    readonly issues: readonly RecordingValidationIssue[];
+    constructor(issues: readonly RecordingValidationIssue[]);
+}
+/** Validate the shared canonical event envelope without applying recording-wide rules. */
+export declare function validateFactoryEventEnvelope(input: unknown, path?: readonly (string | number)[]): RecordingValidationIssue[];
+/** Validate the generated Factory event schema version for any input source. */
+export declare function validateFactoryEventSchemaVersion(input: unknown, path?: readonly (string | number)[]): RecordingValidationIssue[];
+export declare function safeParseFactoryRecording(input: unknown): SafeParseFactoryRecordingResult;
+export declare function parseFactoryRecording(input: unknown): FactoryRecording;

package/dist/recording.js

@@ -0,0 +1,236 @@
+import { FACTORY_EVENT_SCHEMA_VERSIONS, FACTORY_EVENT_TYPES, } from "./contracts.js";
+import { orderFactoryEvents } from "./event-ordering.js";
+import { canonicalEventIssues, canonicalFactoryIssues, } from "./schema-validation.js";
+export const FACTORY_RECORDING_SCHEMA_VERSION = "factory-recording/v1";
+export class FactoryRecordingValidationError extends Error {
+    issues;
+    constructor(issues) {
+        super(issues.length === 1
+            ? `Factory recording validation failed: ${issues[0]?.message}`
+            : `Factory recording validation failed with ${issues.length} issues`);
+        this.name = "FactoryRecordingValidationError";
+        this.issues = issues;
+    }
+}
+const supportedEventSchemaVersions = new Set(Object.values(FACTORY_EVENT_SCHEMA_VERSIONS));
+const topologyEventTypes = new Set([
+    FACTORY_EVENT_TYPES.FactoryEventTypeRunRequest,
+    FACTORY_EVENT_TYPES.FactoryEventTypeInitialStructureRequest,
+    FACTORY_EVENT_TYPES.FactoryEventTypeFactoryChange,
+]);
+const recordingFields = new Set([
+    "schemaVersion",
+    "id",
+    "title",
+    "summary",
+    "factory",
+    "events",
+]);
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function addRequiredStringIssue(value, key, path, issues) {
+    if (!(key in value)) {
+        issues.push({
+            category: "structure",
+            code: "missing_required_field",
+            path: [...path, key],
+            message: `Expected required field ${key}.`,
+        });
+    }
+    else if (typeof value[key] !== "string") {
+        issues.push({
+            category: "structure",
+            code: "invalid_type",
+            path: [...path, key],
+            message: `Expected ${key} to be a string.`,
+        });
+    }
+}
+function validateFactoryDefinition(input, path, issues) {
+    issues.push(...canonicalFactoryIssues(input, path));
+}
+/** Validate the shared canonical event envelope without applying recording-wide rules. */
+export function validateFactoryEventEnvelope(input, path = []) {
+    return canonicalEventIssues(input, path);
+}
+function hasUsableFactoryDefinition(input) {
+    return (isRecord(input) &&
+        typeof input.name === "string" &&
+        input.name.trim().length > 0);
+}
+function validateEventSchemaVersions(events, issues) {
+    for (const [index, event] of events.entries()) {
+        issues.push(...validateFactoryEventSchemaVersion(event, ["events", index]));
+    }
+}
+/** Validate the generated Factory event schema version for any input source. */
+export function validateFactoryEventSchemaVersion(input, path = []) {
+    if (!isRecord(input) ||
+        typeof input.schemaVersion !== "string" ||
+        supportedEventSchemaVersions.has(input.schemaVersion)) {
+        return [];
+    }
+    return [
+        {
+            category: "semantic",
+            code: "unsupported_event_schema_version",
+            path: [...path, "schemaVersion"],
+            message: `Unsupported Factory event schema version: ${input.schemaVersion}.`,
+        },
+    ];
+}
+function validateUniqueEventIds(events, issues) {
+    const locationsById = new Map();
+    for (const [index, event] of events.entries()) {
+        const locations = locationsById.get(event.id) ?? [];
+        locations.push(index);
+        locationsById.set(event.id, locations);
+    }
+    for (const [eventId, locations] of locationsById) {
+        if (locations.length < 2) {
+            continue;
+        }
+        const locationList = locations.join(", ");
+        for (const index of locations) {
+            issues.push({
+                category: "semantic",
+                code: "duplicate_event_id",
+                path: ["events", index, "id"],
+                message: `Event ID ${eventId} is duplicated at event indexes ${locationList}.`,
+            });
+        }
+    }
+}
+function validateFactorySessionIdentity(events, issues) {
+    const sessionIds = events.map((event) => isRecord(event.context) && typeof event.context.sessionId === "string"
+        ? event.context.sessionId
+        : undefined);
+    const presentSessionIds = new Set(sessionIds.filter((sessionId) => sessionId !== undefined));
+    const identitiesAreMixed = presentSessionIds.size > 1 ||
+        (presentSessionIds.size === 1 && sessionIds.some((id) => id === undefined));
+    if (!identitiesAreMixed) {
+        return;
+    }
+    for (const [index, sessionId] of sessionIds.entries()) {
+        issues.push({
+            category: "semantic",
+            code: "mixed_factory_session_identity",
+            path: ["events", index, "context", "sessionId"],
+            message: sessionId === undefined
+                ? "Expected a Factory Session ID consistent with the other recording events."
+                : `Factory Session ID ${sessionId} is inconsistent with the recording event history.`,
+        });
+    }
+}
+function validateTopologyBootstrap(factory, events, issues) {
+    const hasTopologyEvent = events.some((event) => typeof event.type === "string" &&
+        topologyEventTypes.has(event.type) &&
+        isRecord(event.payload) &&
+        hasUsableFactoryDefinition(event.payload.factory));
+    if (!hasUsableFactoryDefinition(factory) && !hasTopologyEvent) {
+        issues.push({
+            category: "semantic",
+            code: "missing_topology_bootstrap",
+            path: ["events"],
+            message: "Expected a usable top-level factory or a topology-establishing Factory event.",
+        });
+    }
+}
+function validateRecordingSemantics(input, events) {
+    const issues = [];
+    validateEventSchemaVersions(events, issues);
+    validateUniqueEventIds(events, issues);
+    validateFactorySessionIdentity(events, issues);
+    validateTopologyBootstrap(input.factory, events, issues);
+    return issues;
+}
+export function safeParseFactoryRecording(input) {
+    if (!isRecord(input)) {
+        return {
+            success: false,
+            issues: [
+                {
+                    category: "structure",
+                    code: "invalid_type",
+                    path: [],
+                    message: "Expected Factory recording to be an object.",
+                },
+            ],
+        };
+    }
+    const issues = [];
+    for (const key of Object.keys(input)) {
+        if (!recordingFields.has(key)) {
+            issues.push({
+                category: "structure",
+                code: "unsupported_field",
+                path: [key],
+                message: `Unsupported field ${key}.`,
+            });
+        }
+    }
+    addRequiredStringIssue(input, "schemaVersion", [], issues);
+    addRequiredStringIssue(input, "id", [], issues);
+    addRequiredStringIssue(input, "title", [], issues);
+    if (typeof input.schemaVersion === "string" &&
+        input.schemaVersion !== FACTORY_RECORDING_SCHEMA_VERSION) {
+        issues.push({
+            category: "structure",
+            code: "unsupported_recording_schema_version",
+            path: ["schemaVersion"],
+            message: `Unsupported Factory recording schema version: ${input.schemaVersion}.`,
+        });
+    }
+    if (input.summary !== undefined && typeof input.summary !== "string") {
+        issues.push({
+            category: "structure",
+            code: "invalid_type",
+            path: ["summary"],
+            message: "Expected summary to be a string when present.",
+        });
+    }
+    if (input.factory !== undefined) {
+        validateFactoryDefinition(input.factory, ["factory"], issues);
+    }
+    if (!("events" in input)) {
+        issues.push({
+            category: "structure",
+            code: "missing_required_field",
+            path: ["events"],
+            message: "Expected required field events.",
+        });
+    }
+    else if (!Array.isArray(input.events)) {
+        issues.push({
+            category: "structure",
+            code: "invalid_type",
+            path: ["events"],
+            message: "Expected events to be an array.",
+        });
+    }
+    else {
+        for (const [index, event] of input.events.entries()) {
+            issues.push(...validateFactoryEventEnvelope(event, ["events", index]));
+        }
+    }
+    if (issues.length === 0 && Array.isArray(input.events)) {
+        issues.push(...validateRecordingSemantics(input, input.events));
+    }
+    return issues.length > 0
+        ? { success: false, issues }
+        : {
+            success: true,
+            data: {
+                ...input,
+                events: orderFactoryEvents(input.events),
+            },
+        };
+}
+export function parseFactoryRecording(input) {
+    const result = safeParseFactoryRecording(input);
+    if (!result.success) {
+        throw new FactoryRecordingValidationError(result.issues);
+    }
+    return result.data;
+}

package/dist/replay.d.ts

@@ -0,0 +1,21 @@
+import type { FactoryEvent } from "./contracts.js";
+import { type RecordingValidationIssueCode } from "./recording.js";
+export type FactoryReplayTextIssueCode = "malformed_event_json" | RecordingValidationIssueCode;
+export interface FactoryReplayTextIssue {
+    code: FactoryReplayTextIssueCode;
+    path: readonly (string | number)[];
+    message: string;
+}
+export type SafeParseFactoryEventReplayTextResult = {
+    success: true;
+    data: FactoryEvent[];
+} | {
+    success: false;
+    issues: readonly FactoryReplayTextIssue[];
+};
+export declare class FactoryReplayTextParseError extends Error {
+    readonly issues: readonly FactoryReplayTextIssue[];
+    constructor(issues: readonly FactoryReplayTextIssue[]);
+}
+export declare function safeParseFactoryEventReplayText(replayText: string): SafeParseFactoryEventReplayTextResult;
+export declare function parseFactoryEventReplayText(replayText: string): FactoryEvent[];

package/dist/replay.js

@@ -0,0 +1,82 @@
+import { orderFactoryEvents } from "./event-ordering.js";
+import { validateFactoryEventEnvelope, validateFactoryEventSchemaVersion, } from "./recording.js";
+export class FactoryReplayTextParseError extends Error {
+    issues;
+    constructor(issues) {
+        super(issues.length === 1
+            ? `Factory replay text parsing failed: ${issues[0]?.message}`
+            : `Factory replay text parsing failed with ${issues.length} issues`);
+        this.name = "FactoryReplayTextParseError";
+        this.issues = issues;
+    }
+}
+function dataFrames(replayText) {
+    const normalizedText = replayText
+        .replaceAll("\r\n", "\n")
+        .replaceAll("\r", "\n");
+    const frames = [];
+    for (const block of normalizedText.split(/\n[\t ]*\n/)) {
+        const dataLines = [];
+        for (const line of block.split("\n")) {
+            if (line.startsWith(":")) {
+                continue;
+            }
+            const separator = line.indexOf(":");
+            const field = separator === -1 ? line : line.slice(0, separator);
+            if (field !== "data") {
+                continue;
+            }
+            let value = separator === -1 ? "" : line.slice(separator + 1);
+            if (value.startsWith(" ")) {
+                value = value.slice(1);
+            }
+            dataLines.push(value);
+        }
+        if (dataLines.length > 0) {
+            frames.push(dataLines.join("\n"));
+        }
+    }
+    return frames;
+}
+export function safeParseFactoryEventReplayText(replayText) {
+    const events = [];
+    const issues = [];
+    for (const [frameIndex, data] of dataFrames(replayText).entries()) {
+        let input;
+        try {
+            input = JSON.parse(data);
+        }
+        catch {
+            issues.push({
+                code: "malformed_event_json",
+                path: ["frames", frameIndex, "data"],
+                message: "Expected SSE data to contain valid Factory event JSON.",
+            });
+            continue;
+        }
+        const framePath = ["frames", frameIndex, "data"];
+        const validationIssues = [
+            ...validateFactoryEventEnvelope(input, framePath),
+            ...validateFactoryEventSchemaVersion(input, framePath),
+        ];
+        if (validationIssues.length > 0) {
+            issues.push(...validationIssues.map(({ code, path, message }) => ({
+                code,
+                path,
+                message,
+            })));
+            continue;
+        }
+        events.push(input);
+    }
+    return issues.length > 0
+        ? { success: false, issues }
+        : { success: true, data: orderFactoryEvents(events) };
+}
+export function parseFactoryEventReplayText(replayText) {
+    const result = safeParseFactoryEventReplayText(replayText);
+    if (!result.success) {
+        throw new FactoryReplayTextParseError(result.issues);
+    }
+    return result.data;
+}

package/dist/schema-validation.d.ts

@@ -0,0 +1,9 @@
+export type CanonicalSchemaIssueCode = "invalid_type" | "invalid_value" | "missing_required_field" | "unsupported_event_type" | "unsupported_field";
+export interface CanonicalSchemaIssue {
+    category: "structure";
+    code: CanonicalSchemaIssueCode;
+    path: readonly (string | number)[];
+    message: string;
+}
+export declare function canonicalFactoryIssues(input: unknown, path: readonly (string | number)[]): CanonicalSchemaIssue[];
+export declare function canonicalEventIssues(input: unknown, path: readonly (string | number)[]): CanonicalSchemaIssue[];

package/dist/schema-validation.js

@@ -0,0 +1,113 @@
+import Ajv2020, {} from "ajv/dist/2020.js";
+import addFormats from "ajv-formats";
+import factorySchema from "./generated/factory.schema.json" with {
+    type: "json"
+};
+import factoryEventSchema from "./generated/factory-event.schema.json" with {
+    type: "json"
+};
+const ajv = new Ajv2020({
+    allErrors: true,
+    coerceTypes: false,
+    removeAdditional: false,
+    strict: false,
+    useDefaults: false,
+});
+addFormats(ajv);
+const canonicalEventSchema = factoryEventSchema;
+const { $id: _eventSchemaId, discriminator: _eventDiscriminator, oneOf: eventVariants = [], ...eventEnvelopeSchema } = canonicalEventSchema;
+const validateEventEnvelopeShape = ajv.compile(eventEnvelopeSchema);
+const validateFactoryShape = ajv.compile(factorySchema);
+const eventValidators = new Map();
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+for (const variant of eventVariants) {
+    const variantProperties = variant.properties;
+    const typeSchemaInput = isRecord(variantProperties)
+        ? variantProperties.type
+        : undefined;
+    const typeSchema = isRecord(typeSchemaInput) ? typeSchemaInput : undefined;
+    const eventType = typeSchema?.const;
+    if (typeof eventType !== "string") {
+        continue;
+    }
+    eventValidators.set(eventType, ajv.compile({
+        ...eventEnvelopeSchema,
+        properties: {
+            ...eventEnvelopeSchema.properties,
+            ...(isRecord(variantProperties) ? variantProperties : {}),
+        },
+    }));
+}
+function pointerSegments(pointer) {
+    if (pointer.length === 0) {
+        return [];
+    }
+    return pointer
+        .slice(1)
+        .split("/")
+        .map((segment) => segment.replaceAll("~1", "/").replaceAll("~0", "~"));
+}
+function issuePath(error, path) {
+    const segments = pointerSegments(error.instancePath).map((segment) => (/^(0|[1-9]\d*)$/.test(segment) ? Number(segment) : segment));
+    const property = error.keyword === "required"
+        ? error.params.missingProperty
+        : error.keyword === "additionalProperties"
+            ? error.params.additionalProperty
+            : undefined;
+    return typeof property === "string"
+        ? [...path, ...segments, property]
+        : [...path, ...segments];
+}
+function issueCode(error) {
+    if (error.keyword === "required")
+        return "missing_required_field";
+    if (error.keyword === "additionalProperties")
+        return "unsupported_field";
+    if (error.keyword === "type")
+        return "invalid_type";
+    if (error.keyword === "enum" && error.instancePath === "/type") {
+        return "unsupported_event_type";
+    }
+    return "invalid_value";
+}
+function issues(errors, path) {
+    return (errors ?? [])
+        .filter((error) => !(error.keyword === "enum" && error.instancePath === "/schemaVersion"))
+        .map((error) => {
+        const pathToIssue = issuePath(error, path);
+        const field = pathToIssue.at(-1);
+        return {
+            category: "structure",
+            code: issueCode(error),
+            path: pathToIssue,
+            message: error.keyword === "required"
+                ? `Expected required field ${String(field)}.`
+                : error.keyword === "additionalProperties"
+                    ? `Unsupported field ${String(field)}.`
+                    : `Expected ${pathToIssue.join(".") || "value"} to satisfy the canonical contract: ${error.message ?? error.keyword}.`,
+        };
+    });
+}
+export function canonicalFactoryIssues(input, path) {
+    return validateFactoryShape(input)
+        ? []
+        : issues(validateFactoryShape.errors, path);
+}
+export function canonicalEventIssues(input, path) {
+    if (!isRecord(input)) {
+        return [
+            {
+                category: "structure",
+                code: "invalid_type",
+                path,
+                message: "Expected Factory event to be an object.",
+            },
+        ];
+    }
+    const validator = typeof input.type === "string"
+        ? (eventValidators.get(input.type) ?? validateEventEnvelopeShape)
+        : validateEventEnvelopeShape;
+    return validator(input) ? [] : issues(validator.errors, path);
+}

package/dist/visualization-layout-contracts.d.ts

@@ -0,0 +1,63 @@
+export declare const FACTORY_VISUALIZATION_LAYOUT_SCHEMA_VERSION: "factory-visualization-layout/v1";
+export type FactoryVisualizationNoteTone = "neutral" | "accent" | "info" | "success" | "warning" | "danger";
+export interface FactoryVisualizationPosition {
+    x: number;
+    y: number;
+}
+export interface FactoryVisualizationSize {
+    width: number;
+    height: number;
+}
+export interface FactoryVisualizationEmbeddedImageSource {
+    kind: "embedded";
+    mediaType: "image/png" | "image/jpeg" | "image/webp";
+    base64: string;
+}
+export interface FactoryVisualizationImageContent {
+    kind: "image";
+    altText: string;
+    source: FactoryVisualizationEmbeddedImageSource;
+}
+export interface FactoryVisualizationNoteAnnotation {
+    id: string;
+    kind: "note";
+    position: FactoryVisualizationPosition;
+    size?: FactoryVisualizationSize;
+    title?: string;
+    body: string;
+    tone?: FactoryVisualizationNoteTone;
+}
+export interface FactoryVisualizationImageAnnotation extends FactoryVisualizationImageContent {
+    id: string;
+    position: FactoryVisualizationPosition;
+    size: FactoryVisualizationSize;
+}
+export type FactoryVisualizationAnnotation = FactoryVisualizationNoteAnnotation | FactoryVisualizationImageAnnotation;
+export interface FactoryVisualizationTextEmptyState {
+    kind: "text";
+    text: string;
+}
+export interface FactoryVisualizationNodeEmptyState {
+    nodeId: string;
+    content: FactoryVisualizationTextEmptyState | FactoryVisualizationImageContent;
+}
+/** Presentation-only metadata carried beside, never inside, a canonical Factory. */
+export interface FactoryVisualizationLayoutV1 {
+    schemaVersion: typeof FACTORY_VISUALIZATION_LAYOUT_SCHEMA_VERSION;
+    annotations?: FactoryVisualizationAnnotation[];
+    nodeEmptyStates?: FactoryVisualizationNodeEmptyState[];
+}
+export type FactoryVisualizationLayoutIssueCode = "invalid_type" | "non_plain_data" | "invalid_value" | "missing_required_field" | "unsupported_field" | "unsupported_layout_schema_version" | "invalid_annotation_kind" | "invalid_empty_state_kind" | "duplicate_annotation_id" | "duplicate_node_id" | "empty_node_id" | "unknown_canonical_node_id" | "empty_text" | "text_too_long" | "unsafe_html" | "unsafe_markdown" | "unsafe_uri" | "unsafe_content_field" | "unsupported_note_tone" | "invalid_coordinate" | "invalid_dimension" | "invalid_base64" | "empty_image_payload" | "unsupported_image_media_type" | "image_media_type_mismatch" | "image_too_large" | "aggregate_image_bytes_exceeded";
+export interface FactoryVisualizationLayoutIssue {
+    category: "structure" | "semantic";
+    code: FactoryVisualizationLayoutIssueCode;
+    path: readonly (string | number)[];
+    message: string;
+}
+export type SafeParseFactoryVisualizationLayoutResult = {
+    success: true;
+    data: FactoryVisualizationLayoutV1;
+} | {
+    success: false;
+    issues: readonly FactoryVisualizationLayoutIssue[];
+};

package/dist/visualization-layout-contracts.js

@@ -0,0 +1 @@
+export const FACTORY_VISUALIZATION_LAYOUT_SCHEMA_VERSION = "factory-visualization-layout/v1";

package/dist/visualization-layout-data.d.ts

@@ -0,0 +1,9 @@
+import type { FactoryVisualizationLayoutIssue } from "./visualization-layout-contracts.js";
+type InputPath = readonly (string | number)[];
+export type InputRecord = Record<string, unknown>;
+export declare function isInputRecord(value: unknown): value is InputRecord;
+/** Reject behavior-bearing containers before the parser reads any input value. */
+export declare function validatePlainDataContainers(value: unknown, path: InputPath, issues: FactoryVisualizationLayoutIssue[]): void;
+/** Copy validated values into fresh standard containers without prototype data. */
+export declare function clonePlainData(value: unknown): unknown;
+export {};