@weasel-js/core 1.10.1 → 1.11.0

package/dist/canvas/SceneCanvas/defaultNodeProperties.js

@@ -1,73 +1,130 @@
-import { KIT_SHAPE_KINDS as e } from "../../core/shapeKinds.js";
-import { settleShapeGenerator as t } from "../../features/paths/shapeGenerator.js";
-import { inferredNodeRouting as n } from "./defaultNodeRouting.js";
-import { SHAPE_GENERATOR_SECTIONS as r } from "./shapeGeneratorProperties.js";
-import { poseLinearOf as i } from "@weasel-js/geom";
-import { dashForStrokeStyle as a, strokeDashStyleOf as o } from "@weasel-js/paint";
-import { listMarkers as s, markerGeneration as c } from "@weasel-js/stroke";
-import { resolveAlign as l } from "@weasel-js/text";
-import { ANGLE_RADIANS as u, decimal as d } from "@weasel-js/quantity";
-import { prefUnit as f } from "@weasel-js/prefs";
+import { minSizeOf } from "../../core/scene/minSize.js";
+import { KIT_SHAPE_KINDS, shapeKindInfo } from "../../core/shapeKinds.js";
+import { settleShapeGenerator } from "../../features/paths/shapeGenerator.js";
+import { inferredNodeRouting } from "./defaultNodeRouting.js";
+import { SHAPE_GENERATOR_SECTIONS } from "./shapeGeneratorProperties.js";
+import { poseLinearOf } from "@weasel-js/geom";
+import { dashForStrokeStyle, strokeDashStyleOf } from "@weasel-js/paint";
+import { listMarkers, markerGeneration } from "@weasel-js/stroke";
+import { resolveAlign } from "@weasel-js/text";
+import { ANGLE_RADIANS, decimal } from "@weasel-js/quantity";
+import { prefUnit } from "@weasel-js/prefs";
+
 //#region src/canvas/SceneCanvas/defaultNodeProperties.ts
-var p = f(u, "deg", {
+/** Radians-stored / degrees-shown conversion for `pose.rotation` leaves.
+*  Display rounds to 0.1° so a canonical radian value doesn't render as
+*  a 15-digit float. */
+var rotationDegreesUnit = prefUnit(ANGLE_RADIANS, "deg", {
 	precision: 1,
 	suffix: "°"
-}), m = d({
+});
+/** How a typed number reads. The stored value keeps every digit a drag or a scale gave it. */
+var TWO_PLACES = decimal({
 	maxPlaces: 2,
-	grouping: !1
+	grouping: false
 });
-function h(e) {
-	let t = e?.width;
-	if (typeof t == "number" || typeof t == "object" && t && typeof t.px == "number") return t;
+/** `Stroke.width` off a partly-typed stroke object, or `undefined`. */
+function strokeWidthOf(stroke) {
+	const w = stroke?.width;
+	if (typeof w === "number") return w;
+	if (typeof w === "object" && w !== null && typeof w.px === "number") return w;
 }
-var g = {
-	read: (e, t) => t === void 0 ? void 0 : o(Array.isArray(e) ? e : void 0, h(t)),
-	write: (e, t) => e === "dashed" || e === "dotted" ? a(e, h(t)) : e === "solid" ? void 0 : t?.dash
-}, _ = {
-	read: (e) => typeof e == "string" ? e : e && typeof e == "object" && "key" in e ? String(e.key) : "",
-	write: (e) => e === "" ? void 0 : e
-}, v = {
-	read: (e) => e === "italic",
-	write: (e) => e ? "italic" : void 0
-}, y = {
-	read: (e, t) => {
-		if (e === "start" || e === "end") {
-			let n = t?.direction;
-			return n === "ltr" || n === "rtl" ? l(e, n) : void 0;
+/** `Stroke.dash` — a stored array of lengths — read and written as a named
+*  style. The presets are multiples of the sibling `width`, which is why the
+*  encoding is handed the whole stroke rather than the field. */
+var strokeDashEncoding = {
+	read: (dash, stroke) => stroke === void 0 ? void 0 : strokeDashStyleOf(Array.isArray(dash) ? dash : void 0, strokeWidthOf(stroke)),
+	write: (style, stroke) => style === "dashed" || style === "dotted" ? dashForStrokeStyle(style, strokeWidthOf(stroke)) : style === "solid" ? void 0 : stroke?.dash
+};
+/** `Stroke.markerStart` / `markerMid` / `markerEnd` — a `MarkerRef` — read and
+*  written as a bare key, with the empty string standing for no marker. */
+var markerEncoding = {
+	read: (ref) => {
+		if (typeof ref === "string") return ref;
+		if (ref && typeof ref === "object" && "key" in ref) return String(ref.key);
+		return "";
+	},
+	write: (value) => value === "" ? void 0 : value
+};
+/** `TextStyle.fontStyle` as an Italic flag. Off removes the field rather than
+*  storing `'normal'`, which is what an absent one already means. */
+var italicEncoding = {
+	read: (stored) => stored === "italic",
+	write: (on) => on ? "italic" : void 0
+};
+/** `TextStyle.align` read as the edge that paints, or as `justify`. The model
+*  also holds the reading-order pair `start` / `end`, which name an edge only
+*  under a stated `direction`. Under `auto` each paragraph takes its own from
+*  its text, so no segment is lit. A click writes the edge. */
+var alignEncoding = {
+	read: (stored, style) => {
+		if (stored === "start" || stored === "end") {
+			const direction = style?.direction;
+			return direction === "ltr" || direction === "rtl" ? resolveAlign(stored, direction) : void 0;
 		}
-		return e;
+		return stored;
 	},
-	write: (e) => e
-}, b = {
-	read: (e) => i({ transform: e }) !== null,
-	write: (e, t) => e ? t?.transform : void 0
-}, x;
-function S() {
-	let e = c();
-	return x?.generation !== e && (x = {
-		generation: e,
+	write: (edge) => edge
+};
+var DEFAULT_NIB = {
+	angle: Math.PI / 6,
+	ratio: .25
+};
+/** `Stroke.nib` as a flag: on keeps the nib held, or starts a default one,
+*  and off removes it. */
+var nibEncoding = {
+	read: (stored) => stored != null && typeof stored === "object",
+	write: (on, stroke) => on ? stroke?.nib ?? DEFAULT_NIB : void 0
+};
+/** `pose.transform` as a flag: on while the pose carries a skew or a per-axis
+*  scale, and off removes it. On keeps the one held, since a flag cannot
+*  author a matrix. */
+var transformEncoding = {
+	read: (stored) => poseLinearOf({ transform: stored }) !== null,
+	write: (on, pose) => on ? pose?.transform : void 0
+};
+/** `data.overflow` as a flag: on is `'clip'`, and off removes the key, since
+*  absent draws past the box. */
+var overflowEncoding = {
+	read: (stored) => stored === "clip",
+	write: (on) => on ? "clip" : void 0
+};
+var markerOptionsCache;
+/** A `select` rather than a `toggle`: nine options will not fit a segmented
+*  strip. One array per state of the registry, so a reader comparing
+*  references sees a change only when the set changed. */
+function markerOptions() {
+	const generation = markerGeneration();
+	if (markerOptionsCache?.generation !== generation) markerOptionsCache = {
+		generation,
 		options: [{
 			value: "",
 			label: "None"
-		}, ...s().map((e) => ({
-			value: e.id,
-			label: e.id
+		}, ...listMarkers().map((m) => ({
+			value: m.id,
+			label: m.id
 		}))]
-	}), x.options;
+	};
+	return markerOptionsCache.options;
 }
-function C(e) {
+function markerLeaf(leaf) {
 	return {
 		kind: "enum",
 		default: "",
 		control: "select",
-		encoding: _,
-		...e,
+		encoding: markerEncoding,
+		...leaf,
 		get options() {
-			return S();
+			return markerOptions();
 		}
 	};
 }
-var w = {
+/** `data.fill` is a whole `Fill`, so it is an object leaf, as the stroke is.
+*  Its field is a `paint` leaf, not a `color` one, because a color control
+*  would read `undefined` off a gradient and write a bare string over it.
+*  `block` for the same reason every stroke field is: the kind bar and the
+*  per-kind editor want the width a 64px label column takes. */
+var FILL_LEAF = {
 	kind: "object",
 	name: "Fill",
 	description: "Fill paint.",
@@ -75,7 +132,7 @@ var w = {
 		kind: "solid",
 		color: "#000000ff"
 	} },
-	block: !0,
+	block: true,
 	children: { paint: {
 		kind: "paint",
 		name: "Fill",
@@ -84,10 +141,34 @@ var w = {
 			kind: "solid",
 			color: "#000000ff"
 		},
-		alpha: !0,
-		block: !0
+		alpha: true,
+		block: true
 	} }
-}, T = {
+};
+/** A text node's `data.background`: a `Fill`, as `data.fill` is, painted over
+*  the whole box rather than the glyphs. */
+var BACKGROUND_LEAF = {
+	...FILL_LEAF,
+	name: "Background",
+	description: "Paint behind the text, over the whole box.",
+	default: { paint: {
+		kind: "solid",
+		color: "#ffffffff"
+	} },
+	children: { paint: {
+		kind: "paint",
+		name: "Background",
+		description: "Paint behind the text.",
+		default: {
+			kind: "solid",
+			color: "#ffffffff"
+		},
+		alpha: true,
+		block: true
+	} }
+};
+/** A whole `Stroke`: paint and line geometry, one value. */
+var STROKE_LEAF = {
 	kind: "object",
 	name: "Stroke",
 	description: "Stroke paint and line geometry.",
@@ -98,20 +179,20 @@ var w = {
 		},
 		width: 1
 	},
-	block: !0,
+	block: true,
 	children: {
 		width: {
 			kind: "number",
 			name: "Width",
 			description: "Stroke width, world units.",
-			absentIsDefault: !0,
+			absentIsDefault: true,
 			default: 1,
 			min: 0,
 			max: 20,
 			step: .5,
 			control: "slider",
-			icon: "strokeWidth",
-			block: !0
+			icon: /* @icon */ "core:strokeWidth",
+			block: true
 		},
 		paint: {
 			kind: "paint",
@@ -121,17 +202,17 @@ var w = {
 				kind: "solid",
 				color: "#000000ff"
 			},
-			alpha: !0,
-			block: !0
+			alpha: true,
+			block: true
 		},
 		cap: {
 			kind: "enum",
 			name: "Cap",
 			description: "How an open end is drawn.",
-			absentIsDefault: !0,
+			absentIsDefault: true,
 			default: "butt",
 			control: "toggle",
-			block: !0,
+			block: true,
 			pair: {
 				with: ["data.stroke.join", "data.stroke.align"],
 				label: "Line"
@@ -140,17 +221,17 @@ var w = {
 				{
 					value: "butt",
 					label: "Butt",
-					icon: "capButt"
+					icon: /* @icon */ "core:capButt"
 				},
 				{
 					value: "round",
 					label: "Round",
-					icon: "capRound"
+					icon: /* @icon */ "core:capRound"
 				},
 				{
 					value: "square",
 					label: "Square",
-					icon: "capSquare"
+					icon: /* @icon */ "core:capSquare"
 				}
 			]
 		},
@@ -158,25 +239,25 @@ var w = {
 			kind: "enum",
 			name: "Join",
 			description: "How a corner is drawn.",
-			absentIsDefault: !0,
+			absentIsDefault: true,
 			default: "miter",
 			control: "toggle",
-			block: !0,
+			block: true,
 			options: [
 				{
 					value: "miter",
 					label: "Miter",
-					icon: "joinMiter"
+					icon: /* @icon */ "core:joinMiter"
 				},
 				{
 					value: "round",
 					label: "Round",
-					icon: "joinRound"
+					icon: /* @icon */ "core:joinRound"
 				},
 				{
 					value: "bevel",
 					label: "Bevel",
-					icon: "joinBevel"
+					icon: /* @icon */ "core:joinBevel"
 				}
 			]
 		},
@@ -184,25 +265,25 @@ var w = {
 			kind: "enum",
 			name: "Align",
 			description: "Where the ribbon sits relative to the edge.",
-			absentIsDefault: !0,
+			absentIsDefault: true,
 			default: "center",
 			control: "toggle",
-			block: !0,
+			block: true,
 			options: [
 				{
 					value: "inner",
 					label: "Inner",
-					icon: "alignInner"
+					icon: /* @icon */ "core:alignInner"
 				},
 				{
 					value: "center",
 					label: "Center",
-					icon: "alignCenter"
+					icon: /* @icon */ "core:alignCenter"
 				},
 				{
 					value: "outer",
 					label: "Outer",
-					icon: "alignOuter"
+					icon: /* @icon */ "core:alignOuter"
 				}
 			]
 		},
@@ -212,58 +293,97 @@ var w = {
 			description: "Solid, dashed or dotted. Dash lengths are multiples of the stroke width, so a style holds as the width changes.",
 			default: "solid",
 			control: "toggle",
-			block: !0,
-			encoding: g,
+			block: true,
+			encoding: strokeDashEncoding,
 			options: [
 				{
 					value: "solid",
 					label: "Solid",
-					icon: "dashSolid"
+					icon: /* @icon */ "core:dashSolid"
 				},
 				{
 					value: "dashed",
 					label: "Dashed",
-					icon: "dashDashed"
+					icon: /* @icon */ "core:dashDashed"
 				},
 				{
 					value: "dotted",
 					label: "Dotted",
-					icon: "dashDotted"
+					icon: /* @icon */ "core:dashDotted"
 				},
 				{
 					value: "custom",
 					label: "Custom",
-					icon: "dashCustom",
-					disabled: !0
+					icon: /* @icon */ "core:dashCustom",
+					disabled: true
 				}
 			]
 		},
-		markerStart: C({
+		nib: {
+			kind: "boolean",
+			name: "Nib",
+			description: "A broad pen: the stroke is its full width moving across the nib, and thinner moving along it.",
+			default: false,
+			control: "switch",
+			block: true,
+			encoding: nibEncoding
+		},
+		"nib.angle": {
+			kind: "number",
+			name: "Angle",
+			description: "The nib's edge, counterclockwise from level.",
+			default: DEFAULT_NIB.angle,
+			step: 1,
+			unit: rotationDegreesUnit,
+			block: true,
+			showIf: { path: "data.stroke.nib" },
+			pair: {
+				with: "data.stroke.nib.ratio",
+				label: "Nib"
+			}
+		},
+		"nib.ratio": {
+			kind: "number",
+			name: "Thinnest",
+			description: "The width moving along the nib, as a fraction of the width moving across it.",
+			default: DEFAULT_NIB.ratio,
+			min: 0,
+			max: 1,
+			step: .05,
+			control: "slider",
+			block: true,
+			showIf: { path: "data.stroke.nib" }
+		},
+		markerStart: markerLeaf({
 			name: "Start",
 			description: "Marker at the first vertex of each open subpath.",
-			block: !0,
+			block: true,
 			pair: {
 				with: ["data.stroke.markerMid", "data.stroke.markerEnd"],
 				label: "Markers"
 			}
 		}),
-		markerMid: C({
+		markerMid: markerLeaf({
 			name: "Mid",
 			description: "Marker at every interior authored vertex.",
-			block: !0
+			block: true
 		}),
-		markerEnd: C({
+		markerEnd: markerLeaf({
 			name: "End",
 			description: "Marker at the last vertex of each open subpath.",
-			block: !0
+			block: true
 		})
 	}
-}, E = {
+};
+/** A box side's floor: the node's `data.minSize`, which resize and insert hold it to as well. */
+var minSizeAt = (side) => (read) => minSizeOf({ minSize: read("data.minSize") })?.[side];
+/** The pose box, its rotation, and the `transform` inside that. */
+var LAYOUT = {
 	name: "Layout",
 	members: {
 		"pose.x": {
 			kind: "number",
-			display: m,
+			display: TWO_PLACES,
 			name: "X",
 			description: "Left edge, world units.",
 			default: 0,
@@ -274,18 +394,19 @@ var w = {
 		},
 		"pose.y": {
 			kind: "number",
-			display: m,
+			display: TWO_PLACES,
 			name: "Y",
 			description: "Top edge, world units.",
 			default: 0
 		},
 		"pose.width": {
 			kind: "number",
-			display: m,
+			display: TWO_PLACES,
 			name: "W",
 			description: "Width, world units.",
 			default: 0,
 			min: 0,
+			minAt: minSizeAt("width"),
 			pair: {
 				with: "pose.height",
 				label: "Size"
@@ -293,11 +414,12 @@ var w = {
 		},
 		"pose.height": {
 			kind: "number",
-			display: m,
+			display: TWO_PLACES,
 			name: "H",
 			description: "Height, world units.",
 			default: 0,
-			min: 0
+			min: 0,
+			minAt: minSizeAt("height")
 		},
 		"pose.rotation": {
 			kind: "number",
@@ -305,44 +427,49 @@ var w = {
 			description: "Rotation about the box center.",
 			default: 0,
 			step: 1,
-			unit: p,
-			absentIsDefault: !0
+			unit: rotationDegreesUnit,
+			absentIsDefault: true
 		},
 		"pose.transform": {
 			kind: "boolean",
 			name: "Skew",
 			description: "The skew or per-axis scale the box and rotation cannot hold. Off removes it.",
-			default: !1,
+			default: false,
 			control: "switch",
-			encoding: b
+			encoding: transformEncoding
 		}
 	}
 };
-function D(e = {}) {
+/** Build the standard shape schema — Layout (pose box + rotation) +
+*  Appearance (fill / stroke), optionally a Text group. Matches the kit's
+*  builtin-shape data template (`{ path, fill, stroke?, text? }`,
+*  `useBuiltinShapeTools`). */
+function shapeSchema(opts = {}) {
 	return {
 		name: "Properties",
 		members: {
-			layout: E,
-			...Object.fromEntries((e.generators ?? []).map((e) => [e, r[e]])),
-			...e.text ? { content: {
+			layout: LAYOUT,
+			...Object.fromEntries((opts.generators ?? []).map((g) => [g, SHAPE_GENERATOR_SECTIONS[g]])),
+			...opts.text ? { content: {
 				name: "Content",
 				members: { "data.text": {
 					kind: "string",
 					name: "Text",
 					description: "Text content.",
-					absentIsDefault: !0,
+					absentIsDefault: true,
 					default: "",
-					block: !0
+					block: true
 				} }
 			} } : {},
 			appearance: {
 				name: "",
 				members: {
-					"data.fill": w,
-					"data.stroke": T
+					"data.fill": FILL_LEAF,
+					...opts.text ? { "data.background": BACKGROUND_LEAF } : {},
+					"data.stroke": STROKE_LEAF
 				}
 			},
-			...e.text ? { text: {
+			...opts.text ? { text: {
 				name: "",
 				members: {
 					"data.style": {
@@ -350,8 +477,8 @@ function D(e = {}) {
 						name: "Style",
 						description: "Typography for the whole node. Its color is the node's own `data.fill`, in Appearance.",
 						default: {},
-						absentIsDefault: !0,
-						block: !0,
+						absentIsDefault: true,
+						block: true,
 						children: {
 							character: {
 								name: "Character",
@@ -360,15 +487,15 @@ function D(e = {}) {
 										kind: "font-family",
 										name: "Font",
 										description: "Registered font family.",
-										absentIsDefault: !0,
+										absentIsDefault: true,
 										default: "sans-serif"
 									},
 									fontSize: {
 										kind: "number",
-										display: m,
+										display: TWO_PLACES,
 										name: "Size",
 										description: "Font size, world units.",
-										absentIsDefault: !0,
+										absentIsDefault: true,
 										default: 16,
 										min: 1,
 										step: 1,
@@ -381,16 +508,16 @@ function D(e = {}) {
 										kind: "font-weight",
 										name: "Weight",
 										description: "Font weight, from the faces the family has.",
-										absentIsDefault: !0,
+										absentIsDefault: true,
 										default: 400
 									},
 									fontStyle: {
 										kind: "boolean",
 										name: "Italic",
 										description: "Set the text in its italic face.",
-										default: !1,
+										default: false,
 										control: "toggle",
-										icon: "italic",
+										icon: /* @icon */ "core:italic",
 										short: ["I"],
 										pair: {
 											with: [
@@ -401,36 +528,36 @@ function D(e = {}) {
 											],
 											label: "Style"
 										},
-										encoding: v
+										encoding: italicEncoding
 									},
 									underline: {
 										kind: "boolean",
 										name: "Underline",
 										description: "Underline the text.",
-										absentIsDefault: !0,
-										default: !1,
+										absentIsDefault: true,
+										default: false,
 										control: "toggle",
-										icon: "underline",
+										icon: /* @icon */ "core:underline",
 										short: ["U"]
 									},
 									strikethrough: {
 										kind: "boolean",
 										name: "Strikethrough",
 										description: "Strike through the text.",
-										absentIsDefault: !0,
-										default: !1,
+										absentIsDefault: true,
+										default: false,
 										control: "toggle",
-										icon: "strikethrough",
+										icon: /* @icon */ "core:strikethrough",
 										short: ["S"]
 									},
 									overline: {
 										kind: "boolean",
 										name: "Overline",
 										description: "Rule the text above its ascent.",
-										absentIsDefault: !0,
-										default: !1,
+										absentIsDefault: true,
+										default: false,
 										control: "toggle",
-										icon: "overline",
+										icon: /* @icon */ "core:overline",
 										short: ["O"]
 									},
 									script: {
@@ -439,23 +566,23 @@ function D(e = {}) {
 										description: "Set the text smaller and raised or lowered, on the line it would otherwise hold.",
 										default: void 0,
 										control: "toggle",
-										clearable: !0,
+										clearable: true,
 										options: [{
 											value: "super",
 											label: "Superscript",
-											icon: "superscript"
+											icon: /* @icon */ "core:superscript"
 										}, {
 											value: "sub",
 											label: "Subscript",
-											icon: "subscript"
+											icon: /* @icon */ "core:subscript"
 										}]
 									},
 									letterSpacing: {
 										kind: "number",
-										display: m,
+										display: TWO_PLACES,
 										name: "Tracking",
 										description: "Extra advance per glyph, world units.",
-										absentIsDefault: !0,
+										absentIsDefault: true,
 										default: 0,
 										step: .1
 									},
@@ -463,7 +590,7 @@ function D(e = {}) {
 										kind: "enum",
 										name: "Case",
 										description: "Draw the text in capitals, lowercase or title case. The text itself is unchanged.",
-										absentIsDefault: !0,
+										absentIsDefault: true,
 										default: "none",
 										control: "toggle",
 										options: [
@@ -493,7 +620,7 @@ function D(e = {}) {
 										kind: "enum",
 										name: "Small caps",
 										description: "Draw lowercase letters as smaller capitals. The text itself is unchanged.",
-										absentIsDefault: !0,
+										absentIsDefault: true,
 										default: "normal",
 										control: "toggle",
 										options: [{
@@ -513,10 +640,10 @@ function D(e = {}) {
 								members: {
 									lineHeight: {
 										kind: "number",
-										display: m,
+										display: TWO_PLACES,
 										name: "Leading",
 										description: "Line height as a multiple of font size.",
-										absentIsDefault: !0,
+										absentIsDefault: true,
 										default: 1.2,
 										min: .5,
 										step: .1
@@ -525,16 +652,16 @@ function D(e = {}) {
 										kind: "boolean",
 										name: "Wrap",
 										description: "Break lines between words at the box width.",
-										absentIsDefault: !0,
-										default: !1,
+										absentIsDefault: true,
+										default: false,
 										control: "switch"
 									},
 									tabSize: {
 										kind: "number",
-										display: m,
+										display: TWO_PLACES,
 										name: "Tab size",
 										description: "Distance between tab stops, in spaces.",
-										absentIsDefault: !0,
+										absentIsDefault: true,
 										default: 8,
 										min: 1,
 										step: 1
@@ -543,7 +670,7 @@ function D(e = {}) {
 										kind: "enum",
 										name: "Direction",
 										description: "Reading direction. Auto takes each paragraph's from its first strong character.",
-										absentIsDefault: !0,
+										absentIsDefault: true,
 										default: "auto",
 										control: "toggle",
 										options: [
@@ -568,30 +695,30 @@ function D(e = {}) {
 										kind: "enum",
 										name: "Align",
 										description: "Horizontal alignment.",
-										absentIsDefault: !0,
+										absentIsDefault: true,
 										default: "left",
 										control: "toggle",
-										encoding: y,
+										encoding: alignEncoding,
 										options: [
 											{
 												value: "left",
 												label: "Left",
-												icon: "textAlignLeft"
+												icon: /* @icon */ "core:textAlignLeft"
 											},
 											{
 												value: "center",
 												label: "Center",
-												icon: "textAlignCenter"
+												icon: /* @icon */ "core:textAlignCenter"
 											},
 											{
 												value: "right",
 												label: "Right",
-												icon: "textAlignRight"
+												icon: /* @icon */ "core:textAlignRight"
 											},
 											{
 												value: "justify",
 												label: "Justify",
-												icon: "textAlignJustify"
+												icon: /* @icon */ "core:textAlignJustify"
 											}
 										]
 									}
@@ -599,54 +726,86 @@ function D(e = {}) {
 							}
 						}
 					},
+					"data.padding": {
+						kind: "number",
+						display: TWO_PLACES,
+						name: "Padding",
+						description: "Inset from the box to the text on every side, world units.",
+						absentIsDefault: true,
+						default: 0,
+						min: 0,
+						step: 1
+					},
 					"data.verticalAlign": {
 						kind: "enum",
 						name: "Vertical",
 						description: "Where the lines sit in the box's height.",
-						absentIsDefault: !0,
+						absentIsDefault: true,
 						default: "top",
 						control: "toggle",
 						options: [
 							{
 								value: "top",
 								label: "Top",
-								icon: "textAlignTop"
+								icon: /* @icon */ "core:textAlignTop"
 							},
 							{
 								value: "center",
 								label: "Middle",
-								icon: "textAlignMiddle"
+								icon: /* @icon */ "core:textAlignMiddle"
 							},
 							{
 								value: "bottom",
 								label: "Bottom",
-								icon: "textAlignBottom"
+								icon: /* @icon */ "core:textAlignBottom"
 							}
 						]
+					},
+					"data.overflow": {
+						kind: "boolean",
+						name: "Clip",
+						description: "Cut the text at the box's edge instead of drawing it past.",
+						default: false,
+						control: "switch",
+						encoding: overflowEncoding
 					}
 				}
 			} } : {}
 		}
 	};
 }
-var O = {
+/** The kinds whose nodes can hold a `data.generator`, and which kinds of it. */
+var GENERATED_KINDS = {
 	polygon: ["polygon"],
 	star: ["star"],
 	path: ["polygon", "star"]
 };
-function k(e) {
-	let n = O[e];
+function shapeEntry(name) {
+	const generators = GENERATED_KINDS[name];
 	return {
-		name: e,
-		schema: D({
-			text: e === "text",
-			...n ? { generators: n } : {}
+		name,
+		schema: shapeSchema({
+			text: shapeKindInfo(name)?.text ?? false,
+			...generators ? { generators } : {}
 		}),
-		...n ? { settle: t } : {}
+		...generators ? { settle: settleShapeGenerator } : {}
 	};
 }
-var A = e.map(k), j = n.map((e) => k(e.name));
-//#endregion
-export { A as defaultNodeProperties, j as inferredNodeProperties, p as rotationDegreesUnit };
+/**
+* Default properties-trait entries covering the kit's built-in shape
+* kinds (`KIT_SHAPE_KINDS`) — the sibling of `defaultNodeRouting`. Every
+* kind gets the standard box schema; `text` adds a Text group. In
+* lockstep with `KIT_SHAPE_KINDS` by construction (derived via `.map`).
+*/
+var defaultNodeProperties = KIT_SHAPE_KINDS.map(shapeEntry);
+/**
+* Properties-trait entries for the *inferred* routing kinds
+* (`inferredNodeRouting`: `text` / `path` / `image`) — the vocabulary
+* consumers produce when they don't tag `data.kind` (e.g. WeaselDraw).
+* In lockstep with `inferredNodeRouting` by construction.
+*/
+var inferredNodeProperties = inferredNodeRouting.map((e) => shapeEntry(e.name));
 
+//#endregion
+export { defaultNodeProperties, inferredNodeProperties, rotationDegreesUnit };
 //# sourceMappingURL=defaultNodeProperties.js.map