@neta-art/cohub 8.23.0 → 9.0.0

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

@@ -1,317 +0,0 @@
-import { z } from "zod";
-//#region ../protocol/dist/board-connection.d.ts
-/** Sides of a node frame a connection can attach to. */
-declare const BOARD_CONNECTION_SIDES: readonly ["top", "right", "bottom", "left"];
-type BoardConnectionSide = (typeof BOARD_CONNECTION_SIDES)[number];
-/**
- * Where a connection meets its node.
- *
- * - `auto` — the side is chosen from the live geometry of both endpoints, so the
- *   connection stays sensible through any move or resize. This is the default and
- *   what almost every connection should use.
- * - `side` — the user pinned a side; `offset` (0..1) positions it along that edge.
- * - `fixed` — the user pinned an exact normalized point on the frame.
- *
- * `auto` is a *declaration of intent*, not a computed value: the resolved side is
- * never written back, so the connection keeps adapting instead of freezing the
- * first layout it happened to have.
- */
-declare const BoardConnectionAnchorSchema: z.ZodUnion<readonly [z.ZodObject<{
-  kind: z.ZodLiteral<"auto">;
-}, z.core.$strip>, z.ZodObject<{
-  kind: z.ZodLiteral<"side">;
-  side: z.ZodEnum<{
-    bottom: "bottom";
-    left: "left";
-    right: "right";
-    top: "top";
-  }>;
-  offset: z.ZodDefault<z.ZodNumber>;
-}, z.core.$strip>, z.ZodObject<{
-  kind: z.ZodLiteral<"fixed">;
-  nx: z.ZodNumber;
-  ny: z.ZodNumber;
-}, z.core.$strip>]>;
-type BoardConnectionAnchor = z.infer<typeof BoardConnectionAnchorSchema>;
-declare const AUTO_BOARD_CONNECTION_ANCHOR: BoardConnectionAnchor;
-declare const BoardConnectionEndpointSchema: z.ZodObject<{
-  itemId: z.ZodString;
-  portId: z.ZodOptional<z.ZodString>;
-  anchor: z.ZodDefault<z.ZodUnion<readonly [z.ZodObject<{
-    kind: z.ZodLiteral<"auto">;
-  }, z.core.$strip>, z.ZodObject<{
-    kind: z.ZodLiteral<"side">;
-    side: z.ZodEnum<{
-      bottom: "bottom";
-      left: "left";
-      right: "right";
-      top: "top";
-    }>;
-    offset: z.ZodDefault<z.ZodNumber>;
-  }, z.core.$strip>, z.ZodObject<{
-    kind: z.ZodLiteral<"fixed">;
-    nx: z.ZodNumber;
-    ny: z.ZodNumber;
-  }, z.core.$strip>]>>;
-}, z.core.$strip>;
-type BoardConnectionEndpoint = z.infer<typeof BoardConnectionEndpointSchema>;
-/**
- * Which ends carry an arrowhead.
- *
- * This is the *semantic* direction, not a style flag: `forward` means the
- * relation reads source → target, `backward` means target → source, and `none`
- * means the relation is symmetric. Renderers derive arrowheads from it, so the
- * drawing can never disagree with the meaning.
- */
-declare const BOARD_CONNECTION_DIRECTIONS: readonly ["none", "forward", "backward", "both"];
-type BoardConnectionDirection = (typeof BOARD_CONNECTION_DIRECTIONS)[number];
-/** How the line travels between its two resolved endpoints. */
-declare const BOARD_CONNECTION_ROUTINGS: readonly ["straight", "curve", "orthogonal"];
-type BoardConnectionRouting = (typeof BOARD_CONNECTION_ROUTINGS)[number];
-declare const BOARD_CONNECTION_LINES: readonly ["solid", "dashed"];
-type BoardConnectionLine = (typeof BOARD_CONNECTION_LINES)[number];
-/**
- * The default relation kind.
- *
- * "related" is deliberately unopinionated: drawing a line between two nodes
- * states that they are connected, not *how*. A stronger claim (depends-on,
- * blocks, ...) is something the user or an agent asserts explicitly.
- */
-declare const DEFAULT_BOARD_RELATION: "related";
-/**
- * Relation kind — a free-form slug, not an enum.
- *
- * Boards are used for domains we do not control, so a closed vocabulary would
- * force unrelated meanings into the wrong bucket. The format is constrained
- * (lowercase, dash/dot separated) so relations stay comparable and queryable
- * across clients instead of accumulating near-duplicate spellings.
- */
-declare const BoardRelationSchema: z.ZodDefault<z.ZodString>;
-/**
- * Waypoints a user dragged the line through, in world space.
- *
- * Stored because they are *input*, not output: the resolved path is recomputed
- * from them on every read, but the intent behind a hand-routed line cannot be
- * recovered once discarded.
- */
-declare const BoardConnectionWaypointSchema: z.ZodObject<{
-  x: z.ZodNumber;
-  y: z.ZodNumber;
-}, z.core.$strip>;
-declare const BoardConnectionRoutingSchema: z.ZodObject<{
-  kind: z.ZodDefault<z.ZodEnum<{
-    curve: "curve";
-    orthogonal: "orthogonal";
-    straight: "straight";
-  }>>;
-  bend: z.ZodDefault<z.ZodNumber>;
-  waypoints: z.ZodDefault<z.ZodArray<z.ZodObject<{
-    x: z.ZodNumber;
-    y: z.ZodNumber;
-  }, z.core.$strip>>>;
-}, z.core.$strip>;
-type BoardConnectionRoutingConfig = z.infer<typeof BoardConnectionRoutingSchema>;
-declare const BoardConnectionStyleSchema: z.ZodObject<{
-  color: z.ZodDefault<z.ZodString>;
-  size: z.ZodDefault<z.ZodNumber>;
-  line: z.ZodDefault<z.ZodEnum<{
-    dashed: "dashed";
-    solid: "solid";
-  }>>;
-}, z.core.$strip>;
-type BoardConnectionStyle = z.infer<typeof BoardConnectionStyleSchema>;
-declare const DEFAULT_BOARD_CONNECTION_ROUTING: BoardConnectionRoutingConfig;
-declare const DEFAULT_BOARD_CONNECTION_STYLE: BoardConnectionStyle;
-declare const BoardConnectionSchema: z.ZodObject<{
-  id: z.ZodString;
-  source: z.ZodObject<{
-    itemId: z.ZodString;
-    portId: z.ZodOptional<z.ZodString>;
-    anchor: z.ZodDefault<z.ZodUnion<readonly [z.ZodObject<{
-      kind: z.ZodLiteral<"auto">;
-    }, z.core.$strip>, z.ZodObject<{
-      kind: z.ZodLiteral<"side">;
-      side: z.ZodEnum<{
-        bottom: "bottom";
-        left: "left";
-        right: "right";
-        top: "top";
-      }>;
-      offset: z.ZodDefault<z.ZodNumber>;
-    }, z.core.$strip>, z.ZodObject<{
-      kind: z.ZodLiteral<"fixed">;
-      nx: z.ZodNumber;
-      ny: z.ZodNumber;
-    }, z.core.$strip>]>>;
-  }, z.core.$strip>;
-  target: z.ZodObject<{
-    itemId: z.ZodString;
-    portId: z.ZodOptional<z.ZodString>;
-    anchor: z.ZodDefault<z.ZodUnion<readonly [z.ZodObject<{
-      kind: z.ZodLiteral<"auto">;
-    }, z.core.$strip>, z.ZodObject<{
-      kind: z.ZodLiteral<"side">;
-      side: z.ZodEnum<{
-        bottom: "bottom";
-        left: "left";
-        right: "right";
-        top: "top";
-      }>;
-      offset: z.ZodDefault<z.ZodNumber>;
-    }, z.core.$strip>, z.ZodObject<{
-      kind: z.ZodLiteral<"fixed">;
-      nx: z.ZodNumber;
-      ny: z.ZodNumber;
-    }, z.core.$strip>]>>;
-  }, z.core.$strip>;
-  relation: z.ZodDefault<z.ZodString>;
-  direction: z.ZodDefault<z.ZodEnum<{
-    backward: "backward";
-    both: "both";
-    forward: "forward";
-    none: "none";
-  }>>;
-  label: z.ZodDefault<z.ZodString>;
-  routing: z.ZodDefault<z.ZodObject<{
-    kind: z.ZodDefault<z.ZodEnum<{
-      curve: "curve";
-      orthogonal: "orthogonal";
-      straight: "straight";
-    }>>;
-    bend: z.ZodDefault<z.ZodNumber>;
-    waypoints: z.ZodDefault<z.ZodArray<z.ZodObject<{
-      x: z.ZodNumber;
-      y: z.ZodNumber;
-    }, z.core.$strip>>>;
-  }, z.core.$strip>>;
-  style: z.ZodDefault<z.ZodObject<{
-    color: z.ZodDefault<z.ZodString>;
-    size: z.ZodDefault<z.ZodNumber>;
-    line: z.ZodDefault<z.ZodEnum<{
-      dashed: "dashed";
-      solid: "solid";
-    }>>;
-  }, z.core.$strip>>;
-  metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-}, z.core.$strict>;
-type BoardConnection = z.infer<typeof BoardConnectionSchema>;
-/** Server-owned fields, mirroring how nodes carry a board id and revision. */
-type BoardConnectionRecord = BoardConnection & {
-  boardId: string;
-  revision: number;
-  createdAt: string | null;
-  updatedAt: string | null;
-};
-/** The client-authored form of a connection (no server-owned fields). */
-type BoardConnectionInput = BoardConnection;
-/**
- * A patch to an existing connection.
- *
- * `id` is excluded: a connection's identity never changes, and re-pointing both
- * endpoints is an edit of the same relation, not a new one.
- */
-declare const BoardConnectionPatchSchema: z.ZodObject<{
-  source: z.ZodOptional<z.ZodObject<{
-    itemId: z.ZodString;
-    portId: z.ZodOptional<z.ZodString>;
-    anchor: z.ZodDefault<z.ZodUnion<readonly [z.ZodObject<{
-      kind: z.ZodLiteral<"auto">;
-    }, z.core.$strip>, z.ZodObject<{
-      kind: z.ZodLiteral<"side">;
-      side: z.ZodEnum<{
-        bottom: "bottom";
-        left: "left";
-        right: "right";
-        top: "top";
-      }>;
-      offset: z.ZodDefault<z.ZodNumber>;
-    }, z.core.$strip>, z.ZodObject<{
-      kind: z.ZodLiteral<"fixed">;
-      nx: z.ZodNumber;
-      ny: z.ZodNumber;
-    }, z.core.$strip>]>>;
-  }, z.core.$strip>>;
-  target: z.ZodOptional<z.ZodObject<{
-    itemId: z.ZodString;
-    portId: z.ZodOptional<z.ZodString>;
-    anchor: z.ZodDefault<z.ZodUnion<readonly [z.ZodObject<{
-      kind: z.ZodLiteral<"auto">;
-    }, z.core.$strip>, z.ZodObject<{
-      kind: z.ZodLiteral<"side">;
-      side: z.ZodEnum<{
-        bottom: "bottom";
-        left: "left";
-        right: "right";
-        top: "top";
-      }>;
-      offset: z.ZodDefault<z.ZodNumber>;
-    }, z.core.$strip>, z.ZodObject<{
-      kind: z.ZodLiteral<"fixed">;
-      nx: z.ZodNumber;
-      ny: z.ZodNumber;
-    }, z.core.$strip>]>>;
-  }, z.core.$strip>>;
-  relation: z.ZodOptional<z.ZodDefault<z.ZodString>>;
-  direction: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
-    backward: "backward";
-    both: "both";
-    forward: "forward";
-    none: "none";
-  }>>>;
-  label: z.ZodOptional<z.ZodDefault<z.ZodString>>;
-  routing: z.ZodOptional<z.ZodDefault<z.ZodObject<{
-    kind: z.ZodDefault<z.ZodEnum<{
-      curve: "curve";
-      orthogonal: "orthogonal";
-      straight: "straight";
-    }>>;
-    bend: z.ZodDefault<z.ZodNumber>;
-    waypoints: z.ZodDefault<z.ZodArray<z.ZodObject<{
-      x: z.ZodNumber;
-      y: z.ZodNumber;
-    }, z.core.$strip>>>;
-  }, z.core.$strip>>>;
-  style: z.ZodOptional<z.ZodDefault<z.ZodObject<{
-    color: z.ZodDefault<z.ZodString>;
-    size: z.ZodDefault<z.ZodNumber>;
-    line: z.ZodDefault<z.ZodEnum<{
-      dashed: "dashed";
-      solid: "solid";
-    }>>;
-  }, z.core.$strip>>>;
-  metadata: z.ZodOptional<z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
-}, z.core.$strict>;
-type BoardConnectionPatch = z.infer<typeof BoardConnectionPatchSchema>;
-/** Both item ids a connection touches, deduped for a self-loop. */
-declare function connectionItemIds(connection: BoardConnection): string[];
-/** Whether a connection touches the given node. */
-declare function connectionTouchesItem(connection: BoardConnection, itemId: string): boolean;
-/** The item at the far end of a connection from `itemId`, or null. */
-declare function connectionOtherItemId(connection: BoardConnection, itemId: string): string | null;
-declare function normalizeBoardConnectionStyle(style: Partial<BoardConnectionStyle> | undefined): BoardConnectionStyle;
-/**
- * Build a connection with every default filled in.
- *
- * Callers only state what they mean (which items, and optionally the relation),
- * so a connection created by the editor, an agent or the CLI is byte-identical
- * for the same intent.
- */
-declare function createBoardConnection(input: {
-  id: string;
-  sourceItemId: string;
-  targetItemId: string;
-  relation?: string;
-  direction?: BoardConnectionDirection;
-  label?: string;
-  sourcePortId?: string;
-  targetPortId?: string;
-  sourceAnchor?: BoardConnectionAnchor;
-  targetAnchor?: BoardConnectionAnchor;
-  routing?: Partial<BoardConnectionRoutingConfig>;
-  style?: Partial<BoardConnectionStyle>;
-  metadata?: Record<string, unknown>;
-}): BoardConnection;
-/** Reverse a connection's endpoints, preserving the relation's reading order. */
-declare function flipBoardConnection(connection: BoardConnection): BoardConnection;
-//#endregion
-export { AUTO_BOARD_CONNECTION_ANCHOR, BOARD_CONNECTION_DIRECTIONS, BOARD_CONNECTION_LINES, BOARD_CONNECTION_ROUTINGS, BOARD_CONNECTION_SIDES, BoardConnection, BoardConnectionAnchor, BoardConnectionAnchorSchema, BoardConnectionDirection, BoardConnectionEndpoint, BoardConnectionEndpointSchema, BoardConnectionInput, BoardConnectionLine, BoardConnectionPatch, BoardConnectionPatchSchema, BoardConnectionRecord, BoardConnectionRouting, BoardConnectionRoutingConfig, BoardConnectionRoutingSchema, BoardConnectionSchema, BoardConnectionSide, BoardConnectionStyle, BoardConnectionStyleSchema, BoardConnectionWaypointSchema, BoardRelationSchema, DEFAULT_BOARD_CONNECTION_ROUTING, DEFAULT_BOARD_CONNECTION_STYLE, DEFAULT_BOARD_RELATION, connectionItemIds, connectionOtherItemId, connectionTouchesItem, createBoardConnection, flipBoardConnection, normalizeBoardConnectionStyle };

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

@@ -1,219 +0,0 @@
-import { BOARD_CONNECTION_STROKE_SIZE, clampBoardStrokeSize } from "./board-constants.js";
-import { z } from "zod";
-//#region ../protocol/dist/board-connection.js
-/**
-* Board connections — the first-class relation between two Board nodes.
-*
-* A connection is *not* a shape. It has no frame of its own: its geometry is
-* derived entirely from the two nodes it joins, which is exactly why it belongs
-* in its own entity rather than in the item list. Storing it as a node would
-* force a bounding box to be persisted and kept in sync with both endpoints —
-* a second source of truth that is stale the moment either node moves.
-*
-* The stored form is therefore purely semantic: which items, in which direction,
-* anchored where, routed how. Every world coordinate is resolved at read time
-* from the live node frames (see the SDK's connection geometry), so a connection
-* can never drift from the nodes it describes.
-*
-* Agents read this model directly: `source`, `target`, `relation` and `label`
-* carry the meaning, while `routing` and `style` carry only presentation. A
-* reader that wants the graph never has to interpret pixels.
-*/
-/** Sides of a node frame a connection can attach to. */
-const BOARD_CONNECTION_SIDES = [
-	"top",
-	"right",
-	"bottom",
-	"left"
-];
-/**
-* Where a connection meets its node.
-*
-* - `auto` — the side is chosen from the live geometry of both endpoints, so the
-*   connection stays sensible through any move or resize. This is the default and
-*   what almost every connection should use.
-* - `side` — the user pinned a side; `offset` (0..1) positions it along that edge.
-* - `fixed` — the user pinned an exact normalized point on the frame.
-*
-* `auto` is a *declaration of intent*, not a computed value: the resolved side is
-* never written back, so the connection keeps adapting instead of freezing the
-* first layout it happened to have.
-*/
-const BoardConnectionAnchorSchema = z.union([
-	z.object({ kind: z.literal("auto") }),
-	z.object({
-		kind: z.literal("side"),
-		side: z.enum(BOARD_CONNECTION_SIDES),
-		offset: z.number().finite().min(0).max(1).default(.5)
-	}),
-	z.object({
-		kind: z.literal("fixed"),
-		nx: z.number().finite().min(0).max(1),
-		ny: z.number().finite().min(0).max(1)
-	})
-]);
-const AUTO_BOARD_CONNECTION_ANCHOR = { kind: "auto" };
-const BoardConnectionEndpointSchema = z.object({
-	itemId: z.string().min(1).max(160),
-	/** Optional semantic port. Older connections omit it and remain valid. */
-	portId: z.string().min(1).max(120).optional(),
-	anchor: BoardConnectionAnchorSchema.default(AUTO_BOARD_CONNECTION_ANCHOR)
-});
-/**
-* Which ends carry an arrowhead.
-*
-* This is the *semantic* direction, not a style flag: `forward` means the
-* relation reads source → target, `backward` means target → source, and `none`
-* means the relation is symmetric. Renderers derive arrowheads from it, so the
-* drawing can never disagree with the meaning.
-*/
-const BOARD_CONNECTION_DIRECTIONS = [
-	"none",
-	"forward",
-	"backward",
-	"both"
-];
-/** How the line travels between its two resolved endpoints. */
-const BOARD_CONNECTION_ROUTINGS = [
-	"straight",
-	"curve",
-	"orthogonal"
-];
-const BOARD_CONNECTION_LINES = ["solid", "dashed"];
-/**
-* The default relation kind.
-*
-* "related" is deliberately unopinionated: drawing a line between two nodes
-* states that they are connected, not *how*. A stronger claim (depends-on,
-* blocks, ...) is something the user or an agent asserts explicitly.
-*/
-const DEFAULT_BOARD_RELATION = "related";
-/**
-* Relation kind — a free-form slug, not an enum.
-*
-* Boards are used for domains we do not control, so a closed vocabulary would
-* force unrelated meanings into the wrong bucket. The format is constrained
-* (lowercase, dash/dot separated) so relations stay comparable and queryable
-* across clients instead of accumulating near-duplicate spellings.
-*/
-const BoardRelationSchema = z.string().min(1).max(64).regex(/^[a-z0-9]+(?:[.-][a-z0-9]+)*$/, "relation must be a lowercase slug").default(DEFAULT_BOARD_RELATION);
-/**
-* Waypoints a user dragged the line through, in world space.
-*
-* Stored because they are *input*, not output: the resolved path is recomputed
-* from them on every read, but the intent behind a hand-routed line cannot be
-* recovered once discarded.
-*/
-const BoardConnectionWaypointSchema = z.object({
-	x: z.number().finite(),
-	y: z.number().finite()
-});
-const BoardConnectionRoutingSchema = z.object({
-	kind: z.enum(BOARD_CONNECTION_ROUTINGS).default("curve"),
-	/** Curve bow as a fraction of endpoint distance (-0.85..0.85). */
-	bend: z.number().finite().min(-.85).max(.85).default(0),
-	waypoints: z.array(BoardConnectionWaypointSchema).max(64).default([])
-});
-const BoardConnectionStyleSchema = z.object({
-	/** Palette color id, resolved to a theme token at render time. */
-	color: z.string().min(1).max(40).default("brand"),
-	size: z.number().finite().positive().default(BOARD_CONNECTION_STROKE_SIZE),
-	line: z.enum(BOARD_CONNECTION_LINES).default("solid")
-});
-const DEFAULT_BOARD_CONNECTION_ROUTING = {
-	kind: "curve",
-	bend: 0,
-	waypoints: []
-};
-const DEFAULT_BOARD_CONNECTION_STYLE = {
-	color: "brand",
-	size: BOARD_CONNECTION_STROKE_SIZE,
-	line: "solid"
-};
-const BoardConnectionSchema = z.object({
-	id: z.string().min(1).max(160),
-	source: BoardConnectionEndpointSchema,
-	target: BoardConnectionEndpointSchema,
-	relation: BoardRelationSchema,
-	direction: z.enum(BOARD_CONNECTION_DIRECTIONS).default("forward"),
-	label: z.string().max(280).default(""),
-	routing: BoardConnectionRoutingSchema.default(DEFAULT_BOARD_CONNECTION_ROUTING),
-	style: BoardConnectionStyleSchema.default(DEFAULT_BOARD_CONNECTION_STYLE),
-	metadata: z.record(z.string(), z.unknown()).default({})
-}).strict();
-/**
-* A patch to an existing connection.
-*
-* `id` is excluded: a connection's identity never changes, and re-pointing both
-* endpoints is an edit of the same relation, not a new one.
-*/
-const BoardConnectionPatchSchema = BoardConnectionSchema.omit({ id: true }).partial();
-/** Both item ids a connection touches, deduped for a self-loop. */
-function connectionItemIds(connection) {
-	return connection.source.itemId === connection.target.itemId ? [connection.source.itemId] : [connection.source.itemId, connection.target.itemId];
-}
-/** Whether a connection touches the given node. */
-function connectionTouchesItem(connection, itemId) {
-	return connection.source.itemId === itemId || connection.target.itemId === itemId;
-}
-/** The item at the far end of a connection from `itemId`, or null. */
-function connectionOtherItemId(connection, itemId) {
-	if (connection.source.itemId === itemId) return connection.target.itemId;
-	if (connection.target.itemId === itemId) return connection.source.itemId;
-	return null;
-}
-function normalizeBoardConnectionStyle(style) {
-	return {
-		color: style?.color?.trim() || DEFAULT_BOARD_CONNECTION_STYLE.color,
-		size: clampBoardStrokeSize(typeof style?.size === "number" && Number.isFinite(style.size) ? style.size : DEFAULT_BOARD_CONNECTION_STYLE.size),
-		line: style?.line ?? DEFAULT_BOARD_CONNECTION_STYLE.line
-	};
-}
-/**
-* Build a connection with every default filled in.
-*
-* Callers only state what they mean (which items, and optionally the relation),
-* so a connection created by the editor, an agent or the CLI is byte-identical
-* for the same intent.
-*/
-function createBoardConnection(input) {
-	return {
-		id: input.id,
-		source: {
-			itemId: input.sourceItemId,
-			...input.sourcePortId ? { portId: input.sourcePortId } : {},
-			anchor: input.sourceAnchor ?? AUTO_BOARD_CONNECTION_ANCHOR
-		},
-		target: {
-			itemId: input.targetItemId,
-			...input.targetPortId ? { portId: input.targetPortId } : {},
-			anchor: input.targetAnchor ?? AUTO_BOARD_CONNECTION_ANCHOR
-		},
-		relation: input.relation ?? "related",
-		direction: input.direction ?? "forward",
-		label: input.label ?? "",
-		routing: {
-			...DEFAULT_BOARD_CONNECTION_ROUTING,
-			...input.routing
-		},
-		style: normalizeBoardConnectionStyle(input.style),
-		metadata: input.metadata ?? {}
-	};
-}
-/** Reverse a connection's endpoints, preserving the relation's reading order. */
-function flipBoardConnection(connection) {
-	const direction = connection.direction === "forward" ? "backward" : connection.direction === "backward" ? "forward" : connection.direction;
-	return {
-		...connection,
-		source: connection.target,
-		target: connection.source,
-		direction,
-		routing: {
-			...connection.routing,
-			bend: -connection.routing.bend,
-			waypoints: [...connection.routing.waypoints].reverse()
-		}
-	};
-}
-//#endregion
-export { AUTO_BOARD_CONNECTION_ANCHOR, BOARD_CONNECTION_DIRECTIONS, BOARD_CONNECTION_LINES, BOARD_CONNECTION_ROUTINGS, BOARD_CONNECTION_SIDES, BoardConnectionAnchorSchema, BoardConnectionEndpointSchema, BoardConnectionPatchSchema, BoardConnectionRoutingSchema, BoardConnectionSchema, BoardConnectionStyleSchema, BoardConnectionWaypointSchema, BoardRelationSchema, DEFAULT_BOARD_CONNECTION_ROUTING, DEFAULT_BOARD_CONNECTION_STYLE, DEFAULT_BOARD_RELATION, connectionItemIds, connectionOtherItemId, connectionTouchesItem, createBoardConnection, flipBoardConnection, normalizeBoardConnectionStyle };