@vizejs/ui 0.387.0 → 0.389.0

package/dist/collapsible.mjs

@@ -0,0 +1,2 @@
+import { n as collapsible_content_default, r as collapsible_root_default, t as collapsible_trigger_default } from "./collapsible-Cra5y_if.mjs";
+export { collapsible_root_default as Collapsible, collapsible_root_default as CollapsibleRoot, collapsible_content_default as CollapsibleContent, collapsible_trigger_default as CollapsibleTrigger };

package/dist/{collection-B_dFZOHO.d.mts → collection-BaPf8lgw.d.mts}

@@ -1,6 +1,6 @@
 import { ComputedRef, MaybeRefOrGetter } from "vue";
 
-//#region src/collection-types.d.ts
+//#region src/families/foundations/collection/collection-types.d.ts
 /** Serializable identity accepted by every collection primitive. */
 type CollectionKey = string | number;
 /** How disabled items participate in focus navigation and typeahead. */
@@ -153,7 +153,7 @@ interface CollectionRegistry<Key extends CollectionKey, Value> {
   readonly dispose: () => boolean;
 }
 //#endregion
-//#region src/collection-registry.d.ts
+//#region src/families/foundations/collection/collection-registry.d.ts
 /**
  * Create an SSR-safe, mutation-aware registry for one compound collection.
  *
@@ -164,7 +164,7 @@ interface CollectionRegistry<Key extends CollectionKey, Value> {
  */
 declare function createCollectionRegistry<Key extends CollectionKey, Value>(options?: CollectionRegistryOptions<Key>): CollectionRegistry<Key, Value>;
 //#endregion
-//#region src/collection-text.d.ts
+//#region src/families/foundations/collection/collection-text.d.ts
 /**
  * Normalize authored or extracted typeahead text without applying a locale.
  *

package/dist/{collection-eHN150dT.mjs → collection-Cncgrq4U.mjs}

@@ -1,5 +1,5 @@
 import { computed, getCurrentScope, onScopeDispose, shallowRef, toValue, watch } from "vue";
-//#region src/collection-keys.ts
+//#region src/families/foundations/collection/collection-keys.ts
 /** Reject keys that cannot serve as stable, serializable item identities. */
 function validateCollectionKey(key) {
 	if (typeof key === "string") {
@@ -41,7 +41,7 @@ function containsAsciiControl(value) {
 	return false;
 }
 //#endregion
-//#region src/collection-observer.ts
+//#region src/families/foundations/collection/collection-observer.ts
 const orderAndTextMutations = {
 	attributeFilter: [
 		"alt",
@@ -113,7 +113,7 @@ function findCollectionObservationRoot(elements) {
 	return null;
 }
 //#endregion
-//#region src/collection-text.ts
+//#region src/families/foundations/collection/collection-text.ts
 const ignoredTextTags = new Set([
 	"NOSCRIPT",
 	"SCRIPT",
@@ -190,7 +190,7 @@ function isCollectionTextHidden(element) {
 	return element.hasAttribute("hidden") || element.hasAttribute("inert") || element.getAttribute("aria-hidden")?.trim().toLowerCase() === "true";
 }
 //#endregion
-//#region src/collection-order.ts
+//#region src/families/foundations/collection/collection-order.ts
 const documentPositionDisconnected = 1;
 const documentPositionPreceding = 2;
 const documentPositionFollowing = 4;
@@ -250,7 +250,7 @@ function sortCollectionRecords(records) {
 	});
 }
 //#endregion
-//#region src/collection-registry.ts
+//#region src/families/foundations/collection/collection-registry.ts
 /**
 * Create an SSR-safe, mutation-aware registry for one compound collection.
 *

package/dist/collection.d.mts

@@ -1,2 +1,2 @@
-import { a as CollectionActiveChangeReason, c as CollectionItemInput, d as CollectionNavigationOptions, f as CollectionRegistration, h as CollectionTextSearchOptions, i as CollectionActiveChange, l as CollectionKey, m as CollectionRegistryOptions, n as normalizeCollectionTextValue, o as CollectionDisabledBehavior, p as CollectionRegistry, r as createCollectionRegistry, s as CollectionItem, t as extractCollectionTextValue, u as CollectionNavigationDirection } from "./collection-B_dFZOHO.mjs";
+import { a as CollectionActiveChangeReason, c as CollectionItemInput, d as CollectionNavigationOptions, f as CollectionRegistration, h as CollectionTextSearchOptions, i as CollectionActiveChange, l as CollectionKey, m as CollectionRegistryOptions, n as normalizeCollectionTextValue, o as CollectionDisabledBehavior, p as CollectionRegistry, r as createCollectionRegistry, s as CollectionItem, t as extractCollectionTextValue, u as CollectionNavigationDirection } from "./collection-BaPf8lgw.mjs";
 export { type CollectionActiveChange, type CollectionActiveChangeReason, type CollectionDisabledBehavior, type CollectionItem, type CollectionItemInput, type CollectionKey, type CollectionNavigationDirection, type CollectionNavigationOptions, type CollectionRegistration, type CollectionRegistry, type CollectionRegistryOptions, type CollectionTextSearchOptions, createCollectionRegistry, extractCollectionTextValue, normalizeCollectionTextValue };

package/dist/collection.mjs

@@ -1,2 +1,2 @@
-import { n as extractCollectionTextValue, r as normalizeCollectionTextValue, t as createCollectionRegistry } from "./collection-eHN150dT.mjs";
+import { n as extractCollectionTextValue, r as normalizeCollectionTextValue, t as createCollectionRegistry } from "./collection-Cncgrq4U.mjs";
 export { createCollectionRegistry, extractCollectionTextValue, normalizeCollectionTextValue };

package/dist/command-CAH0yrMT.d.mts

@@ -0,0 +1,105 @@
+import { MaybeRefOrGetter, ShallowRef } from "vue";
+
+//#region src/families/foundations/command/command-types.d.ts
+/** Context handed to a command implementation when it runs. */
+interface CommandExecution<Id extends string = string> {
+  /** Identifier the dispatch was routed to. */
+  readonly id: Id;
+  /** Caller-supplied argument, or `undefined` for argument-free dispatches. */
+  readonly payload: unknown;
+  /** How the dispatch was initiated, for analytics and help surfaces. */
+  readonly source: CommandDispatchSource;
+}
+/** Origin of one dispatch, threaded through to handlers and observers. */
+type CommandDispatchSource = "imperative" | "menu" | "palette" | "shortcut";
+/** One registerable command definition. */
+interface CommandDefinition<Id extends string = string> {
+  /** Unique identifier; registering a duplicate identifier is a conflict. */
+  readonly id: Id;
+  /** Perform the command. The return value is surfaced on the dispatch. */
+  readonly run: (execution: CommandExecution<Id>) => unknown;
+  /**
+   * Enablement gate; a disabled command stays listed but refuses to run.
+   *
+   * @default true
+   */
+  readonly when?: MaybeRefOrGetter<boolean | undefined>;
+  /** Human-readable name for menus and palettes. */
+  readonly title?: string;
+  /** Longer help text for palettes and documentation surfaces. */
+  readonly description?: string;
+  /** Extra search terms recognized by palettes. */
+  readonly keywords?: readonly string[];
+  /** Grouping label used to cluster related commands in help surfaces. */
+  readonly group?: string;
+}
+/** Immutable help metadata describing one registered command. */
+interface CommandInfo<Id extends string = string> {
+  /** Unique identifier. */
+  readonly id: Id;
+  /** Human-readable name, or `null` when the command is anonymous. */
+  readonly title: string | null;
+  /** Longer help text, or `null`. */
+  readonly description: string | null;
+  /** Extra palette search terms. */
+  readonly keywords: readonly string[];
+  /** Grouping label, or `null`. */
+  readonly group: string | null;
+  /** Read the current enablement without dispatching. */
+  readonly isEnabled: () => boolean;
+}
+/** Immutable outcome of one routed dispatch. */
+interface CommandDispatch<Id extends string = string> {
+  /** Identifier the dispatch targeted. */
+  readonly id: Id;
+  /** Whether the command ran, was disabled, or was not registered. */
+  readonly status: "executed" | "disabled" | "not-found";
+  /** Value returned by the command, or `undefined` when it did not run. */
+  readonly value: unknown;
+  /** Origin threaded through from the dispatch call. */
+  readonly source: CommandDispatchSource;
+}
+/** Options for `createCommandRouter` and `useCommandRouter`. */
+interface CommandRouterOptions<Id extends string = string> {
+  /**
+   * Ignore dispatches while true; every command reads as disabled.
+   *
+   * @default false
+   */
+  readonly isDisabled?: MaybeRefOrGetter<boolean | undefined>;
+  /** Observer called after every dispatch that found its command. */
+  readonly onDidExecute?: (dispatch: CommandDispatch<Id>) => void;
+}
+/** Typed command registry and dispatcher. */
+interface CommandRouter<Id extends string = string> {
+  /** Reactive help metadata for every registered command, in registration order. */
+  readonly commands: Readonly<ShallowRef<readonly CommandInfo<Id>[]>>;
+  /** Register one command and return its releaser. */
+  readonly register: (command: CommandDefinition<Id>) => () => void;
+  /** Report whether an identifier is currently registered. */
+  readonly has: (id: Id) => boolean;
+  /** Read the current enablement of one identifier. */
+  readonly isEnabled: (id: Id) => boolean;
+  /** Route one dispatch and report the routing outcome. */
+  readonly execute: (id: Id, payload?: unknown, options?: {
+    readonly source?: CommandDispatchSource;
+  }) => CommandDispatch<Id>;
+  /** Clear every registration and make imperative calls terminal. */
+  readonly dispose: () => void;
+}
+//#endregion
+//#region src/families/foundations/command/command.d.ts
+/**
+ * Create a typed command router with enablement and help metadata.
+ *
+ * The router owns no DOM and is safe to create during server rendering.
+ * Registering an identifier twice throws a conflict diagnostic so palettes,
+ * menus, and shortcut layers cannot silently shadow one another. Call
+ * {@link CommandRouter.dispose} when using this factory outside a Vue effect
+ * scope.
+ */
+declare function createCommandRouter<Id extends string = string>(options?: CommandRouterOptions<Id>): CommandRouter<Id>;
+/** Create a command router disposed with the current Vue effect scope. */
+declare function useCommandRouter<Id extends string = string>(options?: CommandRouterOptions<Id>): CommandRouter<Id>;
+//#endregion
+export { CommandDispatchSource as a, CommandRouter as c, CommandDispatch as i, CommandRouterOptions as l, useCommandRouter as n, CommandExecution as o, CommandDefinition as r, CommandInfo as s, createCommandRouter as t };

package/dist/command.d.mts

@@ -0,0 +1,2 @@
+import { a as CommandDispatchSource, c as CommandRouter, i as CommandDispatch, l as CommandRouterOptions, n as useCommandRouter, o as CommandExecution, r as CommandDefinition, s as CommandInfo, t as createCommandRouter } from "./command-CAH0yrMT.mjs";
+export { type CommandDefinition, type CommandDispatch, type CommandDispatchSource, type CommandExecution, type CommandInfo, type CommandRouter, type CommandRouterOptions, createCommandRouter, useCommandRouter };

package/dist/command.mjs

@@ -0,0 +1,123 @@
+import { getCurrentScope, onScopeDispose, shallowReadonly, shallowRef, toValue } from "vue";
+//#region src/families/foundations/command/command.ts
+const disposedDiagnostic = "VIZE_UI_COMMAND_DISPOSED";
+const setupDiagnostic = "VIZE_UI_COMMAND_SETUP";
+const optionDiagnostic = "VIZE_UI_COMMAND_OPTION";
+const conflictDiagnostic = "VIZE_UI_COMMAND_CONFLICT";
+const dispatchSources = new Set([
+	"imperative",
+	"menu",
+	"palette",
+	"shortcut"
+]);
+function readBoolean(source, name, fallback) {
+	const value = toValue(source);
+	if (value === void 0) return fallback;
+	if (typeof value !== "boolean") throw new TypeError(`${optionDiagnostic}: ${name} must resolve to a boolean`);
+	return value;
+}
+function validateDefinition(command) {
+	if (typeof command.id !== "string" || command.id === "") throw new TypeError(`${optionDiagnostic}: id must be a non-empty string`);
+	if (typeof command.run !== "function") throw new TypeError(`${optionDiagnostic}: run must be a function`);
+	for (const name of [
+		"title",
+		"description",
+		"group"
+	]) if (command[name] !== void 0 && typeof command[name] !== "string") throw new TypeError(`${optionDiagnostic}: ${name} must be a string`);
+	if (command.keywords !== void 0 && (!Array.isArray(command.keywords) || command.keywords.some((keyword) => typeof keyword !== "string"))) throw new TypeError(`${optionDiagnostic}: keywords must be an array of strings`);
+}
+/**
+* Create a typed command router with enablement and help metadata.
+*
+* The router owns no DOM and is safe to create during server rendering.
+* Registering an identifier twice throws a conflict diagnostic so palettes,
+* menus, and shortcut layers cannot silently shadow one another. Call
+* {@link CommandRouter.dispose} when using this factory outside a Vue effect
+* scope.
+*/
+function createCommandRouter(options = {}) {
+	if (options.onDidExecute !== void 0 && typeof options.onDidExecute !== "function") throw new TypeError(`${optionDiagnostic}: onDidExecute must be a function`);
+	readBoolean(options.isDisabled, "isDisabled", false);
+	const registrations = /* @__PURE__ */ new Map();
+	const commands = shallowRef(Object.freeze([]));
+	let disposed = false;
+	const assertActive = () => {
+		if (disposed) throw new Error(`${disposedDiagnostic}: the router has been disposed`);
+	};
+	const readEnabled = (command) => !readBoolean(options.isDisabled, "isDisabled", false) && readBoolean(command.when, "when", true);
+	const publishCommands = () => {
+		commands.value = Object.freeze([...registrations.values()].map((command) => Object.freeze({
+			id: command.id,
+			title: command.title ?? null,
+			description: command.description ?? null,
+			keywords: Object.freeze([...command.keywords ?? []]),
+			group: command.group ?? null,
+			isEnabled: () => !disposed && registrations.get(command.id) === command && readEnabled(command)
+		})));
+	};
+	const execute = (id, payload, executeOptions = {}) => {
+		assertActive();
+		const source = executeOptions.source ?? "imperative";
+		if (!dispatchSources.has(source)) throw new TypeError(`${optionDiagnostic}: source must be imperative, menu, palette, or shortcut`);
+		const command = registrations.get(id);
+		const finish = (status, value) => {
+			const dispatch = Object.freeze({
+				id,
+				status,
+				value,
+				source
+			});
+			if (command !== void 0) options.onDidExecute?.(dispatch);
+			return dispatch;
+		};
+		if (command === void 0) return finish("not-found", void 0);
+		if (!readEnabled(command)) return finish("disabled", void 0);
+		const execution = Object.freeze({
+			id,
+			payload,
+			source
+		});
+		return finish("executed", command.run(execution));
+	};
+	return Object.freeze({
+		commands: shallowReadonly(commands),
+		register(command) {
+			assertActive();
+			validateDefinition(command);
+			const existing = registrations.get(command.id);
+			if (existing !== void 0) throw new TypeError(`${conflictDiagnostic}: "${command.id}" is already registered` + (existing.title ? ` as "${existing.title}"` : ""));
+			registrations.set(command.id, command);
+			publishCommands();
+			return () => {
+				if (registrations.get(command.id) !== command) return;
+				registrations.delete(command.id);
+				if (!disposed) publishCommands();
+			};
+		},
+		has(id) {
+			assertActive();
+			return registrations.has(id);
+		},
+		isEnabled(id) {
+			assertActive();
+			const command = registrations.get(id);
+			return command !== void 0 && readEnabled(command);
+		},
+		execute,
+		dispose: () => {
+			if (disposed) return;
+			disposed = true;
+			registrations.clear();
+			commands.value = Object.freeze([]);
+		}
+	});
+}
+/** Create a command router disposed with the current Vue effect scope. */
+function useCommandRouter(options = {}) {
+	if (!getCurrentScope()) throw new Error(`${setupDiagnostic}: use inside component setup or an active effect scope`);
+	const router = createCommandRouter(options);
+	onScopeDispose(router.dispose);
+	return router;
+}
+//#endregion
+export { createCommandRouter, useCommandRouter };

package/dist/{composite-navigation-Skx3LZsv.mjs → composite-navigation-D6WKS_BY.mjs}

@@ -1,6 +1,6 @@
-import { t as createTypeahead } from "./typeahead-B7KDxE_u.mjs";
+import { t as createTypeahead } from "./typeahead-DZSBI5m5.mjs";
 import { getCurrentScope, onScopeDispose, toValue } from "vue";
-//#region src/composite-navigation-internal.ts
+//#region src/families/foundations/composite-navigation/composite-navigation-internal.ts
 const optionDiagnostic = "VIZE_UI_COMPOSITE_NAVIGATION_OPTION";
 function capture(errors, callback) {
 	try {
@@ -109,7 +109,7 @@ function validateCommand(value) {
 	return value;
 }
 //#endregion
-//#region src/composite-navigation-dom.ts
+//#region src/families/foundations/composite-navigation/composite-navigation-dom.ts
 function eventElement(value) {
 	const candidate = value;
 	return candidate?.nodeType === 1 && typeof candidate.getRootNode === "function" ? candidate : null;
@@ -166,7 +166,7 @@ function validateActiveDescendant(host, item, id, errors) {
 	errors.push(/* @__PURE__ */ new Error("VIZE_UI_COMPOSITE_NAVIGATION_RELATIONSHIP: active descendant must be contained, aria-owned, or controlled by a supported input role"));
 }
 //#endregion
-//#region src/composite-navigation.ts
+//#region src/families/foundations/composite-navigation/composite-navigation.ts
 const disposedDiagnostic = "VIZE_UI_COMPOSITE_NAVIGATION_DISPOSED";
 const itemDiagnostic = "VIZE_UI_COMPOSITE_NAVIGATION_ITEM";
 const setupDiagnostic = "VIZE_UI_COMPOSITE_NAVIGATION_SETUP";

package/dist/{composite-navigation-QINW9GLy.d.mts → composite-navigation-i7ocwmio.d.mts}

@@ -1,8 +1,8 @@
-import { l as CollectionKey, p as CollectionRegistry, s as CollectionItem } from "./collection-B_dFZOHO.mjs";
-import { a as TypeaheadOptions, r as TypeaheadController } from "./typeahead-BbgUB2Bj.mjs";
+import { l as CollectionKey, p as CollectionRegistry, s as CollectionItem } from "./collection-BaPf8lgw.mjs";
+import { a as TypeaheadOptions, r as TypeaheadController } from "./typeahead-Dl6w5PAN.mjs";
 import { ComputedRef, MaybeRefOrGetter } from "vue";
 
-//#region src/composite-navigation-types.d.ts
+//#region src/families/foundations/composite-navigation/composite-navigation-types.d.ts
 /** Physical axes recognized by composite arrow-key navigation. */
 type CompositeOrientation = "both" | "horizontal" | "vertical";
 /** Reading direction used to map horizontal arrows. */
@@ -106,7 +106,7 @@ interface CompositeNavigationController<Key extends CollectionKey> {
   readonly dispose: () => void;
 }
 //#endregion
-//#region src/composite-navigation.d.ts
+//#region src/families/foundations/composite-navigation/composite-navigation.d.ts
 /** Create an SSR-safe roving-tabindex or active-descendant collection adapter. */
 declare function createCompositeNavigation<Key extends CollectionKey, Value>(options: CompositeNavigationOptions<Key, Value>): CompositeNavigationController<Key>;
 /** Create a composite adapter disposed with the current Vue effect scope. */

package/dist/composite-navigation.d.mts

@@ -1,2 +1,2 @@
-import { a as CompositeDirection, c as CompositeNavigationBaseOptions, d as CompositeNavigationController, f as CompositeNavigationIntent, h as RovingNavigationOptions, i as CompositeContainerProps, l as CompositeNavigationChange, m as CompositeOrientation, n as useCompositeNavigation, o as CompositeFocusStrategy, p as CompositeNavigationOptions, r as ActiveDescendantNavigationOptions, s as CompositeItemProps, t as createCompositeNavigation, u as CompositeNavigationCommand } from "./composite-navigation-QINW9GLy.mjs";
+import { a as CompositeDirection, c as CompositeNavigationBaseOptions, d as CompositeNavigationController, f as CompositeNavigationIntent, h as RovingNavigationOptions, i as CompositeContainerProps, l as CompositeNavigationChange, m as CompositeOrientation, n as useCompositeNavigation, o as CompositeFocusStrategy, p as CompositeNavigationOptions, r as ActiveDescendantNavigationOptions, s as CompositeItemProps, t as createCompositeNavigation, u as CompositeNavigationCommand } from "./composite-navigation-i7ocwmio.mjs";
 export { type ActiveDescendantNavigationOptions, type CompositeContainerProps, type CompositeDirection, type CompositeFocusStrategy, type CompositeItemProps, type CompositeNavigationBaseOptions, type CompositeNavigationChange, type CompositeNavigationCommand, type CompositeNavigationController, type CompositeNavigationIntent, type CompositeNavigationOptions, type CompositeOrientation, type RovingNavigationOptions, createCompositeNavigation, useCompositeNavigation };

package/dist/composite-navigation.mjs

@@ -1,2 +1,2 @@
-import { n as useCompositeNavigation, t as createCompositeNavigation } from "./composite-navigation-Skx3LZsv.mjs";
+import { n as useCompositeNavigation, t as createCompositeNavigation } from "./composite-navigation-D6WKS_BY.mjs";
 export { createCompositeNavigation, useCompositeNavigation };

package/dist/container-5lSCSbeX.mjs

@@ -0,0 +1,113 @@
+import { t as _plugin_vue_export_helper_default } from "./_plugin-vue_export-helper-BOaGB7Aw.mjs";
+import { computed, createBlock, defineComponent, guardReactiveProps, mergeProps, normalizeProps, openBlock, renderSlot, resolveDynamicComponent, useTemplateRef, withCtx } from "vue";
+const CONTAINER_MAX_INLINE_SIZES = {
+	xs: "36rem",
+	sm: "48rem",
+	md: "64rem",
+	lg: "80rem",
+	xl: "96rem",
+	full: "none"
+};
+function normalizeContainerLength(length) {
+	if (typeof length === "number") return length === 0 ? "0" : `${length}px`;
+	return length;
+}
+/** Resolve public Container props into a native CSS logical sizing contract. */
+function resolveContainerLayout(options) {
+	const size = options.size ?? "md";
+	const maxInlineSize = normalizeContainerLength(options.maxInlineSize ?? CONTAINER_MAX_INLINE_SIZES[size]);
+	const paddingInline = normalizeContainerLength(options.paddingInline ?? 0);
+	const centered = options.centered ?? true;
+	const baseStyle = {
+		"--vize-ui-container-max-inline-size": maxInlineSize,
+		"--vize-ui-container-padding-inline": paddingInline,
+		maxInlineSize: "var(--vize-ui-container-max-inline-size)",
+		paddingInline: "var(--vize-ui-container-padding-inline)"
+	};
+	return {
+		centered,
+		maxInlineSize,
+		paddingInline,
+		size,
+		style: centered ? {
+			...baseStyle,
+			marginInline: "auto"
+		} : baseStyle
+	};
+}
+//#endregion
+//#region src/families/layout/container/container.vue
+var container_default = /*#__PURE__*/ _plugin_vue_export_helper_default(/* @__PURE__ */ defineComponent({
+	__name: "container",
+	props: {
+		as: {
+			type: null,
+			required: false,
+			default: "div"
+		},
+		size: {
+			type: String,
+			required: false,
+			default: "md"
+		},
+		maxInlineSize: {
+			type: [String, Number],
+			required: false
+		},
+		paddingInline: {
+			type: [String, Number],
+			required: false,
+			default: 0
+		},
+		centered: {
+			type: Boolean,
+			required: false,
+			default: true
+		}
+	},
+	setup(__props, { expose: __expose }) {
+		const element = useTemplateRef("element");
+		const layout = computed(() => resolveContainerLayout({
+			centered: __props.centered,
+			maxInlineSize: __props.maxInlineSize,
+			paddingInline: __props.paddingInline,
+			size: __props.size
+		}));
+		const centeredState = computed(() => layout.value.centered);
+		const maxInlineSizeState = computed(() => layout.value.maxInlineSize);
+		const paddingInlineState = computed(() => layout.value.paddingInline);
+		const sizeState = computed(() => layout.value.size);
+		const containerStyle = computed(() => layout.value.style);
+		const slotState = computed(() => ({
+			centered: centeredState.value,
+			maxInlineSize: maxInlineSizeState.value,
+			paddingInline: paddingInlineState.value,
+			size: sizeState.value,
+			style: containerStyle.value
+		}));
+		const intrinsicProps = computed(() => ({ style: containerStyle.value }));
+		__expose({
+			centered: centeredState,
+			element,
+			maxInlineSize: maxInlineSizeState,
+			paddingInline: paddingInlineState,
+			size: sizeState,
+			style: containerStyle
+		});
+		return (_ctx, _cache) => {
+			return openBlock(), createBlock(resolveDynamicComponent(__props.as), mergeProps({
+				ref_key: "element",
+				ref: element,
+				part: "root",
+				"data-vize-ui": "container",
+				"data-size": sizeState.value,
+				"data-centered": centeredState.value ? "true" : "false"
+			}, intrinsicProps.value), {
+				default: withCtx(() => [renderSlot(_ctx.$slots, "default", normalizeProps(guardReactiveProps(slotState.value)), void 0, true)]),
+				_: 3
+			}, 16, ["data-size", "data-centered"]);
+		};
+	}
+}), [["__scopeId", "data-v-83c68da5"]]);
+//#endregion
+export { container_default as t };

package/dist/container-CYSiwCA-.d.mts

@@ -0,0 +1,99 @@
+import { t as PrimitiveAs } from "./primitive-BE2mdUcw.mjs";
+import { ComponentPublicInstance } from "vue";
+
+//#region src/families/layout/container/container-types.d.ts
+/** Named max-inline-size preset supported by {@link Container}. */
+type ContainerSize = "xs" | "sm" | "md" | "lg" | "xl" | "full";
+/** Native CSS length, percentage, keyword, or custom property accepted by {@link Container}. */
+type ContainerLength = string | number;
+/** CSS-ready value published after numeric lengths are normalized. */
+type ContainerResolvedLength = string;
+/** Rendered value exposed by {@link Container}. */
+type ContainerElement = Element | ComponentPublicInstance;
+/** Inline style hooks applied to the rendered Container host. */
+interface ContainerStyle {
+  /** Consumer-overridable max inline size hook read by the host declaration. */
+  readonly "--vize-ui-container-max-inline-size": ContainerResolvedLength;
+  /** Consumer-overridable inline padding hook read by the host declaration. */
+  readonly "--vize-ui-container-padding-inline": ContainerResolvedLength;
+  /** Native logical max inline size declaration. */
+  readonly maxInlineSize: string;
+  /** Native logical inline padding declaration. */
+  readonly paddingInline: string;
+  /** Native logical margin declaration applied only when centering is enabled. */
+  readonly marginInline?: "auto";
+}
+/** State exposed to the default Container slot. */
+interface ContainerSlotState {
+  /** Resolved named max-inline-size preset. */
+  readonly size: ContainerSize;
+  /** Resolved CSS max inline size value. */
+  readonly maxInlineSize: ContainerResolvedLength;
+  /** Resolved CSS inline padding value. */
+  readonly paddingInline: ContainerResolvedLength;
+  /** Whether the host uses logical auto margins. */
+  readonly centered: boolean;
+  /** Native logical style object applied to the host. */
+  readonly style: ContainerStyle;
+}
+/** Resolved layout state published by {@link Container}. */
+type ContainerResolvedLayout = ContainerSlotState;
+/** Public instance state exposed by the Container primitive. */
+interface ContainerExpose extends ContainerSlotState {
+  /** Rendered host element or component instance. */
+  readonly element: ContainerElement | null;
+}
+//#endregion
+//#region src/families/layout/container/container.vue.d.ts
+type __VLS_Props = {
+  /**
+   * Native element, custom element, or component to render.
+   *
+   * @default "div"
+   */
+  readonly as?: PrimitiveAs;
+  /**
+   * Named max-inline-size preset.
+   *
+   * @default "md"
+   */
+  readonly size?: ContainerSize;
+  /**
+   * Native CSS `max-inline-size` override. Numbers resolve to px lengths.
+   *
+   * @default undefined
+   */
+  readonly maxInlineSize?: ContainerLength;
+  /**
+   * Native CSS `padding-inline` value. Numbers resolve to px lengths.
+   *
+   * @default 0
+   */
+  readonly paddingInline?: ContainerLength;
+  /**
+   * Center the host with logical inline auto margins.
+   *
+   * @default true
+   */
+  readonly centered?: boolean;
+};
+type __VLS_Slots = {
+  /** Renders container children with the resolved logical sizing state. */default(props: ContainerSlotState): unknown;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {
+  centered: import("vue").ComputedRef<boolean>;
+  element: Readonly<import("vue").ShallowRef<ContainerElement | null>>;
+  maxInlineSize: import("vue").ComputedRef<string>;
+  paddingInline: import("vue").ComputedRef<string>;
+  size: import("vue").ComputedRef<ContainerSize>;
+  style: import("vue").ComputedRef<ContainerStyle>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+type __VLS_WithSlots<T, S> = T & {
+  new (): {
+    $slots: S;
+  };
+};
+//#endregion
+export { ContainerResolvedLayout as a, ContainerSlotState as c, ContainerLength as i, ContainerStyle as l, ContainerElement as n, ContainerResolvedLength as o, ContainerExpose as r, ContainerSize as s, _default as t };

package/dist/container.d.mts

@@ -0,0 +1,2 @@
+import { a as ContainerResolvedLayout, c as ContainerSlotState, i as ContainerLength, l as ContainerStyle, n as ContainerElement, o as ContainerResolvedLength, r as ContainerExpose, s as ContainerSize, t as _default } from "./container-CYSiwCA-.mjs";
+export { _default as Container, type ContainerElement, type ContainerExpose, type ContainerLength, type ContainerResolvedLayout, type ContainerResolvedLength, type ContainerSize, type ContainerSlotState, type ContainerStyle };

package/dist/container.mjs

@@ -0,0 +1,2 @@
+import { t as container_default } from "./container-5lSCSbeX.mjs";
+export { container_default as Container };

package/dist/context-7SpwFHtK.d.mts

@@ -0,0 +1,25 @@
+import { InjectionKey } from "vue";
+
+//#region src/families/foundations/context/context.d.ts
+/** A typed provider and consumer contract for one component family. */
+interface ComponentContext<Value> {
+  /** Human-readable context name used by diagnostics and developer tools. */
+  readonly name: string;
+  /** Public injection key for application-level adapters and test harnesses. */
+  readonly key: InjectionKey<Value>;
+  /** Provides a value from component setup and returns that same value. */
+  readonly provide: (value: Value) => Value;
+  /** Reads the nearest value or throws a stable missing-provider diagnostic. */
+  readonly use: () => Value;
+  /** Reads the nearest value when the provider is intentionally optional. */
+  readonly useOptional: () => Value | undefined;
+}
+/**
+ * Creates an immutable typed context for a compound component family.
+ *
+ * A private sentinel distinguishes a missing provider from a provider whose
+ * value is explicitly `undefined`.
+ */
+declare function createContext<Value>(name: string): ComponentContext<Value>;
+//#endregion
+export { createContext as n, ComponentContext as t };

package/dist/context.d.mts

@@ -1,25 +1,2 @@
-import { InjectionKey } from "vue";
-
-//#region src/context.d.ts
-/** A typed provider and consumer contract for one component family. */
-interface ComponentContext<Value> {
-  /** Human-readable context name used by diagnostics and developer tools. */
-  readonly name: string;
-  /** Public injection key for application-level adapters and test harnesses. */
-  readonly key: InjectionKey<Value>;
-  /** Provides a value from component setup and returns that same value. */
-  readonly provide: (value: Value) => Value;
-  /** Reads the nearest value or throws a stable missing-provider diagnostic. */
-  readonly use: () => Value;
-  /** Reads the nearest value when the provider is intentionally optional. */
-  readonly useOptional: () => Value | undefined;
-}
-/**
- * Creates an immutable typed context for a compound component family.
- *
- * A private sentinel distinguishes a missing provider from a provider whose
- * value is explicitly `undefined`.
- */
-declare function createContext<Value>(name: string): ComponentContext<Value>;
-//#endregion
+import { n as createContext, t as ComponentContext } from "./context-7SpwFHtK.mjs";
 export { ComponentContext, createContext };