@neta-art/cohub 5.9.0 → 6.0.0

package/dist/protocol/dist/board-composition.js

@@ -0,0 +1,318 @@
+import { z } from "zod";
+//#region ../protocol/dist/board-composition.js
+const idSchema = z.string().min(1).max(160);
+const finiteSchema = z.number().finite();
+const jsonObjectSchema = z.record(z.string(), z.unknown());
+const BOARD_EASINGS = [
+	"linear",
+	"ease-in-quad",
+	"ease-out-quad",
+	"ease-in-out-quad",
+	"ease-in-cubic",
+	"ease-out-cubic",
+	"ease-in-out-cubic",
+	"ease-out-quart",
+	"ease-out-expo"
+];
+const BoardEasingSchema = z.enum(BOARD_EASINGS);
+const BoardAnimationTargetSchema = z.discriminatedUnion("type", [
+	z.object({
+		type: z.literal("item"),
+		itemId: idSchema
+	}).strict(),
+	z.object({
+		type: z.literal("effect"),
+		effectId: idSchema
+	}).strict(),
+	z.object({ type: z.literal("camera") }).strict(),
+	z.object({ type: z.literal("board") }).strict()
+]);
+const vector2Schema = z.object({
+	x: finiteSchema,
+	y: finiteSchema
+}).strict();
+const scaleSchema = z.union([finiteSchema.positive(), z.object({
+	x: finiteSchema.positive(),
+	y: finiteSchema.positive()
+}).strict()]);
+const BOARD_ANIMATION_CHANNELS = {
+	"transform.translation": {
+		targets: ["item"],
+		value: vector2Schema,
+		interpolations: ["linear", "step"],
+		coordinateSpace: "world-offset",
+		unit: "board"
+	},
+	"transform.rotation": {
+		targets: ["item"],
+		value: finiteSchema,
+		interpolations: ["linear", "step"],
+		unit: "radian"
+	},
+	"transform.scale": {
+		targets: ["item"],
+		value: scaleSchema,
+		interpolations: ["linear", "step"],
+		unit: "ratio"
+	},
+	"style.opacity": {
+		targets: ["item"],
+		value: finiteSchema.min(0).max(1),
+		interpolations: ["linear", "step"],
+		unit: "ratio"
+	}
+};
+const BoardTrackKeyframeSchema = z.object({
+	time: finiteSchema.nonnegative(),
+	value: z.unknown(),
+	easing: BoardEasingSchema.optional()
+}).strict();
+const BoardTrackSchema = z.object({
+	id: idSchema,
+	target: BoardAnimationTargetSchema,
+	channel: z.string().min(1).max(160),
+	channelVersion: z.number().int().positive().default(1),
+	interpolation: z.enum(["linear", "step"]).default("linear"),
+	fill: z.enum([
+		"none",
+		"backwards",
+		"forwards",
+		"both"
+	]).default("none"),
+	keyframes: z.array(BoardTrackKeyframeSchema).min(1).max(1e5),
+	metadata: jsonObjectSchema.default({})
+}).strict().superRefine((track, context) => {
+	let previous = -1;
+	for (const [index, keyframe] of track.keyframes.entries()) {
+		if (keyframe.time <= previous) context.addIssue({
+			code: "custom",
+			message: "keyframe times must be strictly increasing",
+			path: [
+				"keyframes",
+				index,
+				"time"
+			]
+		});
+		previous = keyframe.time;
+	}
+	const channel = BOARD_ANIMATION_CHANNELS[track.channel];
+	if (!channel) {
+		if (!/^[a-z][a-z0-9]*(?:[.-][a-z0-9]+){2,}$/.test(track.channel)) context.addIssue({
+			code: "custom",
+			message: `unknown channel: ${track.channel}`,
+			path: ["channel"]
+		});
+		return;
+	}
+	if (!channel.targets.includes(track.target.type)) context.addIssue({
+		code: "custom",
+		message: `${track.channel} cannot target ${track.target.type}`,
+		path: ["target"]
+	});
+	if (!channel.interpolations.includes(track.interpolation)) context.addIssue({
+		code: "custom",
+		message: `${track.channel} does not support ${track.interpolation} interpolation`,
+		path: ["interpolation"]
+	});
+	for (const [index, keyframe] of track.keyframes.entries()) {
+		const parsed = channel.value.safeParse(keyframe.value);
+		if (!parsed.success) context.addIssue({
+			code: "custom",
+			message: parsed.error.issues[0]?.message ?? `invalid value for ${track.channel}`,
+			path: [
+				"keyframes",
+				index,
+				"value"
+			]
+		});
+	}
+});
+const extensionKindSchema = z.string().regex(/^[a-z][a-z0-9]*(?:[.-][a-z0-9]+)+$/).max(160);
+const BoardProceduralClipSchema = z.object({
+	id: idSchema,
+	kind: extensionKindSchema,
+	kindVersion: z.number().int().positive(),
+	target: BoardAnimationTargetSchema,
+	start: finiteSchema.nonnegative(),
+	duration: finiteSchema.positive(),
+	layer: z.enum([
+		"behind",
+		"content",
+		"front",
+		"screen"
+	]).default("content"),
+	fill: z.enum([
+		"none",
+		"backwards",
+		"forwards",
+		"both"
+	]).default("none"),
+	easing: BoardEasingSchema.default("linear"),
+	params: jsonObjectSchema.default({}),
+	assetRefs: z.array(z.object({
+		type: z.enum(["space-file", "extension"]),
+		ref: z.string().min(1).max(4096),
+		digest: z.string().min(16).max(160).optional()
+	}).strict()).default([]),
+	seed: idSchema,
+	metadata: jsonObjectSchema.default({})
+}).strict();
+const BoardTimelineMarkerSchema = z.object({
+	id: idSchema,
+	time: finiteSchema.nonnegative(),
+	duration: finiteSchema.nonnegative().optional(),
+	metadata: jsonObjectSchema.default({})
+}).strict();
+const BoardTimelineSchema = z.object({
+	duration: finiteSchema.nonnegative(),
+	tracks: z.array(BoardTrackSchema).max(5e4).default([]),
+	clips: z.array(BoardProceduralClipSchema).max(5e4).default([]),
+	markers: z.array(BoardTimelineMarkerSchema).max(1e4).default([])
+}).strict().superRefine((timeline, context) => {
+	const ids = /* @__PURE__ */ new Set();
+	const channels = /* @__PURE__ */ new Set();
+	for (const [index, track] of timeline.tracks.entries()) {
+		if (ids.has(track.id)) context.addIssue({
+			code: "custom",
+			message: `duplicate timeline id: ${track.id}`,
+			path: [
+				"tracks",
+				index,
+				"id"
+			]
+		});
+		ids.add(track.id);
+		const targetId = track.target.type === "item" ? track.target.itemId : track.target.type === "effect" ? track.target.effectId : track.target.type;
+		const key = `${track.target.type}:${targetId}:${track.channel}`;
+		if (channels.has(key)) context.addIssue({
+			code: "custom",
+			message: `multiple tracks control ${key}`,
+			path: [
+				"tracks",
+				index,
+				"channel"
+			]
+		});
+		channels.add(key);
+		for (const [keyframeIndex, keyframe] of track.keyframes.entries()) if (keyframe.time > timeline.duration) context.addIssue({
+			code: "custom",
+			message: "keyframe exceeds timeline duration",
+			path: [
+				"tracks",
+				index,
+				"keyframes",
+				keyframeIndex,
+				"time"
+			]
+		});
+	}
+	for (const [index, clip] of timeline.clips.entries()) {
+		if (ids.has(clip.id)) context.addIssue({
+			code: "custom",
+			message: `duplicate timeline id: ${clip.id}`,
+			path: [
+				"clips",
+				index,
+				"id"
+			]
+		});
+		ids.add(clip.id);
+		if (clip.start + clip.duration > timeline.duration) context.addIssue({
+			code: "custom",
+			message: "clip exceeds timeline duration",
+			path: [
+				"clips",
+				index,
+				"duration"
+			]
+		});
+	}
+	for (const [index, marker] of timeline.markers.entries()) {
+		if (ids.has(marker.id)) context.addIssue({
+			code: "custom",
+			message: `duplicate timeline id: ${marker.id}`,
+			path: [
+				"markers",
+				index,
+				"id"
+			]
+		});
+		ids.add(marker.id);
+		if (marker.time + (marker.duration ?? 0) > timeline.duration) context.addIssue({
+			code: "custom",
+			message: "marker exceeds timeline duration",
+			path: ["markers", index]
+		});
+	}
+});
+const BoardCompositionPlaybackSchema = z.object({
+	loop: z.boolean().default(false),
+	endBehavior: z.enum(["hold", "reset"]).default("hold"),
+	reducedMotion: z.discriminatedUnion("mode", [
+		z.object({ mode: z.literal("base") }).strict(),
+		z.object({
+			mode: z.literal("time"),
+			time: finiteSchema.nonnegative()
+		}).strict(),
+		z.object({
+			mode: z.literal("marker"),
+			markerId: idSchema
+		}).strict()
+	]).default({ mode: "base" })
+}).strict();
+const compositionFields = {
+	id: idSchema,
+	name: z.string().min(1).max(255),
+	timeline: BoardTimelineSchema,
+	playback: BoardCompositionPlaybackSchema.default({
+		loop: false,
+		endBehavior: "hold",
+		reducedMotion: { mode: "base" }
+	}),
+	metadata: jsonObjectSchema.default({})
+};
+function validateCompositionFallback(composition, context) {
+	const fallback = composition.playback.reducedMotion;
+	if (fallback.mode === "time" && fallback.time > composition.timeline.duration) context.addIssue({
+		code: "custom",
+		message: "reduced-motion time exceeds timeline duration",
+		path: [
+			"playback",
+			"reducedMotion",
+			"time"
+		]
+	});
+	if (fallback.mode === "marker" && !composition.timeline.markers.some((marker) => marker.id === fallback.markerId)) context.addIssue({
+		code: "custom",
+		message: `marker does not exist: ${fallback.markerId}`,
+		path: [
+			"playback",
+			"reducedMotion",
+			"markerId"
+		]
+	});
+}
+const BoardCompositionInputSchema = z.object(compositionFields).strict().superRefine(validateCompositionFallback);
+const BoardCompositionSchema = z.object({
+	...compositionFields,
+	revision: z.number().int().nonnegative().default(0)
+}).strict().superRefine(validateCompositionFallback);
+/** Accept inspect/get output as apply input while stripping server-owned revision. */
+function parseBoardCompositionInput(value) {
+	if (value && typeof value === "object" && !Array.isArray(value)) {
+		const { revision: _revision, ...input } = value;
+		return BoardCompositionInputSchema.parse(input);
+	}
+	return BoardCompositionInputSchema.parse(value);
+}
+Object.entries(BOARD_ANIMATION_CHANNELS).map(([id, definition]) => ({
+	id,
+	version: 1,
+	targets: definition.targets,
+	interpolations: definition.interpolations,
+	..."coordinateSpace" in definition ? { coordinateSpace: definition.coordinateSpace } : {},
+	..."unit" in definition ? { unit: definition.unit } : {},
+	valueSchema: z.toJSONSchema(definition.value)
+}));
+//#endregion
+export { BOARD_ANIMATION_CHANNELS, BOARD_EASINGS, BoardAnimationTargetSchema, BoardCompositionInputSchema, BoardCompositionPlaybackSchema, BoardCompositionSchema, BoardEasingSchema, BoardProceduralClipSchema, BoardTimelineMarkerSchema, BoardTimelineSchema, BoardTrackSchema, parseBoardCompositionInput };

package/dist/protocol/dist/board-constants.d.ts

@@ -1,4 +1,5 @@
 //#region ../protocol/dist/board-constants.d.ts
+type BoardCoordinateSpace = "world" | "frame-local" | "world-offset" | "screen" | "screen-offset" | "normalized";
 type BoardRenderCost = {
   particles: number;
   vertices: number;
@@ -30,4 +31,4 @@ declare const BOARD_STROKE_MIN_SIZE = 1;
 declare const BOARD_STROKE_MAX_SIZE = 64;
 declare function clampBoardStrokeSize(size: number): number;
 //#endregion
-export { BOARD_STROKE_MAX_SIZE, BOARD_STROKE_MIN_SIZE, BoardCapability, BoardRenderCost, clampBoardStrokeSize };
+export { BOARD_STROKE_MAX_SIZE, BOARD_STROKE_MIN_SIZE, BoardCapability, BoardCoordinateSpace, BoardRenderCost, clampBoardStrokeSize };

package/dist/protocol/dist/board-constants.js

@@ -11,7 +11,6 @@ const DEFAULT_BOARD_RENDER_LIMITS = {
 	simulationSteps: 1e5
 };
 const BOARD_BUILTIN_CLIP_KINDS = [
-	"motion.keyframes",
 	"motion.path",
 	"draw.reveal",
 	"draw.handwrite",
@@ -20,9 +19,7 @@ const BOARD_BUILTIN_CLIP_KINDS = [
 	"effects.trail",
 	"effects.impact",
 	"effects.flash",
-	"effects.color",
-	"camera.pan",
-	"camera.zoom",
+	"camera.focus",
 	"camera.shake"
 ];
 const BOARD_BUILTIN_EFFECT_KINDS = ["effects.pulse", "effects.float"];
@@ -60,12 +57,45 @@ function clampBoardStrokeSize(size) {
 */
 const BOARD_FONT_STACK = "\"Geist\", system-ui, -apple-system, \"Noto Sans CJK SC\", \"Noto Sans SC\", \"PingFang SC\", \"Microsoft YaHei\", sans-serif";
 const BOARD_MONO_FONT_STACK = "\"Geist Mono\", \"Fira Code\", ui-monospace, \"Noto Sans Mono CJK SC\", monospace";
-const BOARD_BUILTIN_CAPABILITIES = [...BOARD_BUILTIN_CLIP_KINDS.map((id) => ({
-	kind: "clip",
-	id,
-	version: 1,
-	renderers: ["webgpu", "webgl"]
-})), ...BOARD_BUILTIN_EFFECT_KINDS.map((id) => ({
+function clipSchema(id) {
+	switch (id) {
+		case "motion.path": return { params: { points: {
+			coordinateSpace: "world-offset",
+			unit: "board"
+		} } };
+		case "effects.particles": return { params: { bounds: {
+			coordinateSpace: "world",
+			unit: "board"
+		} } };
+		case "camera.focus": return { params: {
+			focus: {
+				coordinateSpace: "world",
+				unit: "board"
+			},
+			padding: {
+				coordinateSpace: "screen",
+				unit: "css-px"
+			},
+			minZoom: { unit: "ratio" },
+			maxZoom: { unit: "ratio" }
+		} };
+		case "camera.shake": return { params: { amount: {
+			coordinateSpace: "screen-offset",
+			unit: "css-px"
+		} } };
+		default: return;
+	}
+}
+const BOARD_BUILTIN_CAPABILITIES = [...BOARD_BUILTIN_CLIP_KINDS.map((id) => {
+	const schema = clipSchema(id);
+	return {
+		kind: "clip",
+		id,
+		version: 1,
+		renderers: ["webgpu", "webgl"],
+		...schema ? { schema } : {}
+	};
+}), ...BOARD_BUILTIN_EFFECT_KINDS.map((id) => ({
 	kind: "effect",
 	id,
 	version: 1,

package/dist/protocol/dist/board-document.d.ts

@@ -1,5 +1,5 @@
 import { BOARD_DOCUMENT_KIND, BOARD_EXTENSION } from "./board.js";
-import { BOARD_REMOTE_URL_MAX_LENGTH, BoardRemoteUrlSchema, normalizeBoardRemoteUrl } from "./board-url.js";
+import { BOARD_REMOTE_URL_MAX_LENGTH, BoardRemoteUrlSchema, isPublicBoardRemoteAddress, normalizeBoardRemoteUrl } from "./board-url.js";
 import { z } from "zod";
 //#region ../protocol/dist/board-document.d.ts
 declare const BoardFrameSchema: z.ZodObject<{
@@ -33,6 +33,19 @@ declare const BoardAppearanceSchema: z.ZodObject<{
     }>>;
     color: z.ZodOptional<z.ZodString>;
     imageUrl: z.ZodOptional<z.ZodString>;
+    fit: z.ZodOptional<z.ZodEnum<{
+      contain: "contain";
+      cover: "cover";
+      repeat: "repeat";
+    }>>;
+    position: z.ZodOptional<z.ZodEnum<{
+      bottom: "bottom";
+      center: "center";
+      left: "left";
+      right: "right";
+      top: "top";
+    }>>;
+    opacity: z.ZodOptional<z.ZodNumber>;
   }, z.core.$strip>>;
   grid: z.ZodDefault<z.ZodObject<{
     visible: z.ZodDefault<z.ZodBoolean>;
@@ -1024,6 +1037,19 @@ declare const BoardDocumentSchema: z.ZodObject<{
       }>>;
       color: z.ZodOptional<z.ZodString>;
       imageUrl: z.ZodOptional<z.ZodString>;
+      fit: z.ZodOptional<z.ZodEnum<{
+        contain: "contain";
+        cover: "cover";
+        repeat: "repeat";
+      }>>;
+      position: z.ZodOptional<z.ZodEnum<{
+        bottom: "bottom";
+        center: "center";
+        left: "left";
+        right: "right";
+        top: "top";
+      }>>;
+      opacity: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>>;
     grid: z.ZodDefault<z.ZodObject<{
       visible: z.ZodDefault<z.ZodBoolean>;
@@ -1492,4 +1518,4 @@ declare function isMediaItem(item: BoardItem): item is BoardImageItem | BoardVid
 /** Whether an item references a workspace file (media or file card). */
 declare function isFileBackedItem(item: BoardItem): item is BoardImageItem | BoardVideoItem | BoardAudioItem | BoardFileItem;
 //#endregion
-export { BOARD_DOCUMENT_KIND, BOARD_EXTENSION, BOARD_REMOTE_URL_MAX_LENGTH, BOARD_TASK_ARTIFACT_LIMIT, BoardAppearance, BoardAppearanceSchema, BoardArrowItem, BoardArrowItemSchema, BoardAudioItem, BoardAudioItemSchema, BoardDocument, BoardDocumentSchema, BoardDrawItem, BoardDrawItemSchema, BoardFileItem, BoardFileItemSchema, BoardFileSnapshot, BoardFileSnapshotSchema, BoardFrame, BoardFrameItem, BoardFrameItemSchema, BoardFrameSchema, BoardGeoItem, BoardGeoItemSchema, BoardImageItem, BoardImageItemSchema, BoardItem, BoardItemSchema, BoardItemStyle, BoardItemStyleSchema, BoardKnownItem, BoardMediaSnapshot, BoardMediaSnapshotSchema, BoardPoint, BoardPointSchema, BoardRemoteUrlSchema, BoardTaskArtifact, BoardTaskArtifactSchema, BoardTaskItem, BoardTaskItemSchema, BoardTaskSnapshot, BoardTaskSnapshotSchema, BoardTextItem, BoardTextItemSchema, BoardUnknownItem, BoardVideoItem, BoardVideoItemSchema, BoardViewport, BoardViewportSchema, DrawPoint, DrawPointSchema, KNOWN_BOARD_ITEM_TYPES, KnownBoardItemType, SpaceFileRef, SpaceFileRefSchema, UNKNOWN_BOARD_ITEM_TYPE, isFileBackedItem, isMediaItem, isUnknownItem, normalizeBoardRemoteUrl, parseBoardDocument, parseBoardItemLoose, unknownRealType, withResolvedConnections };
+export { BOARD_DOCUMENT_KIND, BOARD_EXTENSION, BOARD_REMOTE_URL_MAX_LENGTH, BOARD_TASK_ARTIFACT_LIMIT, BoardAppearance, BoardAppearanceSchema, BoardArrowItem, BoardArrowItemSchema, BoardAudioItem, BoardAudioItemSchema, BoardDocument, BoardDocumentSchema, BoardDrawItem, BoardDrawItemSchema, BoardFileItem, BoardFileItemSchema, BoardFileSnapshot, BoardFileSnapshotSchema, BoardFrame, BoardFrameItem, BoardFrameItemSchema, BoardFrameSchema, BoardGeoItem, BoardGeoItemSchema, BoardImageItem, BoardImageItemSchema, BoardItem, BoardItemSchema, BoardItemStyle, BoardItemStyleSchema, BoardKnownItem, BoardMediaSnapshot, BoardMediaSnapshotSchema, BoardPoint, BoardPointSchema, BoardRemoteUrlSchema, BoardTaskArtifact, BoardTaskArtifactSchema, BoardTaskItem, BoardTaskItemSchema, BoardTaskSnapshot, BoardTaskSnapshotSchema, BoardTextItem, BoardTextItemSchema, BoardUnknownItem, BoardVideoItem, BoardVideoItemSchema, BoardViewport, BoardViewportSchema, DrawPoint, DrawPointSchema, KNOWN_BOARD_ITEM_TYPES, KnownBoardItemType, SpaceFileRef, SpaceFileRefSchema, UNKNOWN_BOARD_ITEM_TYPE, isFileBackedItem, isMediaItem, isPublicBoardRemoteAddress, isUnknownItem, normalizeBoardRemoteUrl, parseBoardDocument, parseBoardItemLoose, unknownRealType, withResolvedConnections };

package/dist/protocol/dist/board-document.js

@@ -1,7 +1,7 @@
 import { BOARD_ARROW_STROKE_SIZE } from "./board-constants.js";
 import { BoardConnectionSchema } from "./board-connection.js";
 import { BOARD_DOCUMENT_KIND, BOARD_EXTENSION } from "./board.js";
-import { BOARD_REMOTE_URL_MAX_LENGTH, BoardRemoteUrlSchema, normalizeBoardRemoteUrl } from "./board-url.js";
+import { BOARD_REMOTE_URL_MAX_LENGTH, BoardRemoteUrlSchema, isPublicBoardRemoteAddress, normalizeBoardRemoteUrl } from "./board-url.js";
 import { z } from "zod";
 //#region ../protocol/dist/board-document.js
 const BoardFrameSchema = z.object({
@@ -34,7 +34,20 @@ const BoardAppearanceSchema = z.object({
 			"custom"
 		]).default("dots"),
 		color: z.string().optional(),
-		imageUrl: z.string().url().optional()
+		imageUrl: BoardRemoteUrlSchema.optional(),
+		fit: z.enum([
+			"cover",
+			"contain",
+			"repeat"
+		]).optional(),
+		position: z.enum([
+			"center",
+			"top",
+			"bottom",
+			"left",
+			"right"
+		]).optional(),
+		opacity: z.number().finite().min(0).max(1).optional()
 	}).default({ kind: "solid" }),
 	grid: z.object({
 		visible: z.boolean().default(false),
@@ -435,4 +448,4 @@ function isFileBackedItem(item) {
 	return item.type === "image" || item.type === "video" || item.type === "audio" || item.type === "file";
 }
 //#endregion
-export { BOARD_DOCUMENT_KIND, BOARD_EXTENSION, BOARD_REMOTE_URL_MAX_LENGTH, BOARD_TASK_ARTIFACT_LIMIT, BoardAppearanceSchema, BoardArrowItemSchema, BoardAudioItemSchema, BoardDocumentSchema, BoardDrawItemSchema, BoardFileItemSchema, BoardFileSnapshotSchema, BoardFrameItemSchema, BoardFrameSchema, BoardGeoItemSchema, BoardImageItemSchema, BoardItemSchema, BoardItemStyleSchema, BoardMediaSnapshotSchema, BoardPointSchema, BoardRemoteUrlSchema, BoardTaskArtifactSchema, BoardTaskItemSchema, BoardTaskSnapshotSchema, BoardTextItemSchema, BoardVideoItemSchema, BoardViewportSchema, DrawPointSchema, KNOWN_BOARD_ITEM_TYPES, SpaceFileRefSchema, UNKNOWN_BOARD_ITEM_TYPE, isFileBackedItem, isMediaItem, isUnknownItem, normalizeBoardRemoteUrl, parseBoardDocument, parseBoardItemLoose, unknownRealType, withResolvedConnections };
+export { BOARD_DOCUMENT_KIND, BOARD_EXTENSION, BOARD_REMOTE_URL_MAX_LENGTH, BOARD_TASK_ARTIFACT_LIMIT, BoardAppearanceSchema, BoardArrowItemSchema, BoardAudioItemSchema, BoardDocumentSchema, BoardDrawItemSchema, BoardFileItemSchema, BoardFileSnapshotSchema, BoardFrameItemSchema, BoardFrameSchema, BoardGeoItemSchema, BoardImageItemSchema, BoardItemSchema, BoardItemStyleSchema, BoardMediaSnapshotSchema, BoardPointSchema, BoardRemoteUrlSchema, BoardTaskArtifactSchema, BoardTaskItemSchema, BoardTaskSnapshotSchema, BoardTextItemSchema, BoardVideoItemSchema, BoardViewportSchema, DrawPointSchema, KNOWN_BOARD_ITEM_TYPES, SpaceFileRefSchema, UNKNOWN_BOARD_ITEM_TYPE, isFileBackedItem, isMediaItem, isPublicBoardRemoteAddress, isUnknownItem, normalizeBoardRemoteUrl, parseBoardDocument, parseBoardItemLoose, unknownRealType, withResolvedConnections };

package/dist/protocol/dist/board-node.d.ts

@@ -4,15 +4,5 @@ declare const BOARD_COLOR_IDS: readonly ["brand", "neutral", "black", "white", "
 type BoardColorId = (typeof BOARD_COLOR_IDS)[number];
 declare const BOARD_GEO_KINDS: readonly ["rectangle", "rounded", "ellipse", "diamond", "triangle"];
 type BoardGeoKind = (typeof BOARD_GEO_KINDS)[number];
-type BoardNodeValidationDiagnostic = {
-  severity: "error";
-  code: "INVALID_BOARD_NODE" | "INVALID_BOARD_GEOMETRY";
-  message: string;
-  path: string;
-  expected?: string;
-  received?: unknown;
-  allowedValues?: readonly string[];
-  coordinateSpace?: "frame-local" | "world";
-};
 //#endregion
-export { BOARD_COLOR_IDS, BOARD_GEO_KINDS, BoardColorId, BoardGeoKind, BoardNodeValidationDiagnostic };
+export { BOARD_COLOR_IDS, BOARD_GEO_KINDS, BoardColorId, BoardGeoKind };

package/dist/protocol/dist/board-node.js

@@ -155,85 +155,5 @@ function jsonSchema(schema) {
 	return z.toJSONSchema(schema);
 }
 jsonSchema(nodeEnvelopeSchema), Object.fromEntries(BOARD_NATIVE_NODE_TYPES.map((type) => [type, jsonSchema(dataSchemas[type])])), Object.fromEntries(BOARD_NATIVE_NODE_TYPES.map((type) => [type, jsonSchema(viewSchemas[type])]));
-function issueDiagnostic(issue, path) {
-	const fullPath = [path, ...issue.path].join(".");
-	const values = "values" in issue && Array.isArray(issue.values) ? issue.values.filter((value) => typeof value === "string") : void 0;
-	return {
-		severity: "error",
-		code: "INVALID_BOARD_NODE",
-		message: `${fullPath}: ${issue.message}`,
-		path: fullPath,
-		...values?.length ? { allowedValues: values } : {}
-	};
-}
-function drawGeometryDiagnostic(node, data, path) {
-	let minX = Number.POSITIVE_INFINITY;
-	let minY = Number.POSITIVE_INFINITY;
-	let maxX = Number.NEGATIVE_INFINITY;
-	let maxY = Number.NEGATIVE_INFINITY;
-	for (const point of data.points) {
-		const radius = Math.max(.5, data.size / 2 * (.5 + point.p));
-		minX = Math.min(minX, point.x - radius);
-		minY = Math.min(minY, point.y - radius);
-		maxX = Math.max(maxX, point.x + radius);
-		maxY = Math.max(maxY, point.y + radius);
-	}
-	const width = Math.max(1, maxX - minX);
-	const height = Math.max(1, maxY - minY);
-	const tolerance = Math.max(.01, node.width * 1e-6, node.height * 1e-6);
-	if (Math.abs(minX) <= tolerance && Math.abs(minY) <= tolerance && Math.abs(width - node.width) <= tolerance && Math.abs(height - node.height) <= tolerance) return null;
-	return {
-		severity: "error",
-		code: "INVALID_BOARD_GEOMETRY",
-		message: `${path}.data.points must use frame-local coordinates and match the node frame`,
-		path: `${path}.data.points`,
-		expected: "frame-local points with bounds matching width and height",
-		coordinateSpace: "frame-local"
-	};
-}
-function validateBoardNodeInput(node, path = "node") {
-	const envelopeResult = nodeEnvelopeSchema.safeParse(node);
-	if (!envelopeResult.success) return envelopeResult.error.issues.map((issue) => issueDiagnostic(issue, path));
-	if (typeof node.type !== "string" || !BOARD_NATIVE_NODE_TYPES.includes(node.type)) return [{
-		severity: "error",
-		code: "INVALID_BOARD_NODE",
-		message: `${path}.type is not supported`,
-		path: `${path}.type`,
-		expected: "BoardNativeNodeType",
-		received: node.type,
-		allowedValues: BOARD_NATIVE_NODE_TYPES
-	}];
-	const type = node.type;
-	const dataResult = dataSchemas[type].safeParse(node.data ?? {});
-	if (!dataResult.success) return dataResult.error.issues.map((issue) => issueDiagnostic(issue, `${path}.data`));
-	const viewResult = viewSchemas[type].safeParse(node.view ?? {});
-	if (!viewResult.success) return viewResult.error.issues.map((issue) => issueDiagnostic(issue, `${path}.view`));
-	if (type === "image" || type === "video" || type === "audio" || type === "file") {
-		if (node.refKind !== "space_file" || typeof node.refPath !== "string" || !node.refPath) return [{
-			severity: "error",
-			code: "INVALID_BOARD_NODE",
-			message: `${path} requires a space file reference`,
-			path: `${path}.refPath`,
-			expected: "non-empty refPath with refKind space_file"
-		}];
-	}
-	if (type === "draw") {
-		const diagnostic = drawGeometryDiagnostic(node, dataResult.data, path);
-		return diagnostic ? [diagnostic] : [];
-	}
-	if (type === "arrow") {
-		const data = dataResult.data;
-		const inside = (point) => point.x >= node.x && point.x <= node.x + node.width && point.y >= node.y && point.y <= node.y + node.height;
-		if (!inside(data.start) || !inside(data.end)) return [{
-			severity: "error",
-			code: "INVALID_BOARD_GEOMETRY",
-			message: `${path}.data endpoints must be covered by the node frame`,
-			path: `${path}.data`,
-			expected: "world-space endpoints inside the node frame",
-			coordinateSpace: "world"
-		}];
-	}
-	return [];
-}
 //#endregion
-export { BOARD_COLOR_IDS, BOARD_GEO_KINDS, BOARD_NATIVE_NODE_TYPES, BoardColorIdSchema, BoardGeoKindSchema, validateBoardNodeInput };
+export { BOARD_COLOR_IDS, BOARD_GEO_KINDS, BOARD_NATIVE_NODE_TYPES, BoardColorIdSchema, BoardGeoKindSchema };

package/dist/protocol/dist/board-upgrade.d.ts

@@ -0,0 +1 @@
+import "./board.js";

package/dist/protocol/dist/board-upgrade.js

@@ -0,0 +1,2 @@
+import "./board.js";
+export {};

package/dist/protocol/dist/board-url.d.ts

@@ -1,6 +1,7 @@
 import { z } from "zod";
 //#region ../protocol/dist/board-url.d.ts
 declare const BOARD_REMOTE_URL_MAX_LENGTH = 4096;
+declare function isPublicBoardRemoteAddress(value: string): boolean;
 /**
  * Normalize a browser-loadable public HTTP(S) URL. This blocks explicit local
  * addresses; any future server-side fetcher must additionally validate DNS
@@ -9,4 +10,4 @@ declare const BOARD_REMOTE_URL_MAX_LENGTH = 4096;
 declare function normalizeBoardRemoteUrl(value: unknown): string | undefined;
 declare const BoardRemoteUrlSchema: z.ZodString;
 //#endregion
-export { BOARD_REMOTE_URL_MAX_LENGTH, BoardRemoteUrlSchema, normalizeBoardRemoteUrl };
+export { BOARD_REMOTE_URL_MAX_LENGTH, BoardRemoteUrlSchema, isPublicBoardRemoteAddress, normalizeBoardRemoteUrl };

package/dist/protocol/dist/board-url.js

@@ -53,11 +53,16 @@ function isBlockedIpv6(host) {
 	if ((first & 65280) === 65280) return true;
 	return parts[0] === "2001" && parts[1] === "0db8";
 }
+function isPublicBoardRemoteAddress(value) {
+	const address = value.toLowerCase().replace(/^\[|\]$/g, "").replace(/\.$/, "");
+	if (parseIpv4(address)) return !isBlockedIpv4(address);
+	return address.includes(":") && !isBlockedIpv6(address);
+}
 function isBlockedHost(hostname) {
 	const host = hostname.toLowerCase().replace(/^\[|\]$/g, "").replace(/\.$/, "");
 	if (host === "localhost" || host.endsWith(".localhost") || host.endsWith(".local") || host.endsWith(".internal")) return true;
-	if (parseIpv4(host)) return isBlockedIpv4(host);
-	return host.includes(":") && isBlockedIpv6(host);
+	if (parseIpv4(host) || host.includes(":")) return !isPublicBoardRemoteAddress(host);
+	return false;
 }
 /**
 * Normalize a browser-loadable public HTTP(S) URL. This blocks explicit local
@@ -80,4 +85,4 @@ function normalizeBoardRemoteUrl(value) {
 }
 const BoardRemoteUrlSchema = z.string().max(BOARD_REMOTE_URL_MAX_LENGTH).refine((value) => normalizeBoardRemoteUrl(value) !== void 0, { message: "URL must be a public HTTP(S) URL without credentials" });
 //#endregion
-export { BOARD_REMOTE_URL_MAX_LENGTH, BoardRemoteUrlSchema, normalizeBoardRemoteUrl };
+export { BOARD_REMOTE_URL_MAX_LENGTH, BoardRemoteUrlSchema, isPublicBoardRemoteAddress, normalizeBoardRemoteUrl };