@qw-ui/core 0.3.0-next.9 → 0.3.0

package/dist/picker-BykFntQN.js

@@ -0,0 +1,1675 @@
+import { a as modalRequestSend, s as onModalBeforeClose } from "./modal-dialog-machine-CF9_z3Dm.js";
+import { n as createPopupProps, o as popupMachine, t as connectPopup } from "./popup-z5d8IYCt.js";
+import { MachineStatus } from "@zag-js/core";
+//#region src/picker/selection-model.ts
+/** 静默判定落定的内部时长；不是 API，也不是真实惯性承诺（真实触摸见 T029 浏览器验收）。 */
+const QUIET_MS = 40;
+/**
+* 受控值请求后等待调用方回写的内部时长（不是 API）。到期仍未改写 value 即视为拒绝：
+* 显示回到调用方的值并通知一次恢复后的预览（FR-004：受控时组件只发请求，显示跟随调用方）。
+*/
+const OWNER_MS = 100;
+const PAGE_STEP = 5;
+const sameValue = (a, b) => a.length === b.length && a.every((item, index) => item === b[index]);
+const resizeValue = (value, length) => Array.from({ length }, (_, index) => value[index] ?? null);
+/** 可选 = 存在、未禁用、且是该值的逻辑第一项（第一项禁用也不提升后项）。 */
+function isPickerOptionSelectable(column, index) {
+	const option = column.options[index];
+	return !!option && !option.disabled && column.options.findIndex((item) => item.value === option.value) === index;
+}
+/** 列的第一可选值；没有可选项时为 null。 */
+function getPickerFirstValue(column) {
+	return column.options.find((_option, index) => isPickerOptionSelectable(column, index))?.value ?? null;
+}
+/** 值在列中的可选索引；不可选或不存在时为 -1（不伪造选中）。 */
+function getPickerOptionIndex(column, value) {
+	return column.options.findIndex((option, index) => option.value === value && isPickerOptionSelectable(column, index));
+}
+/** 重复值诊断：每个后项一条，指向逻辑第一项。 */
+function getPickerDiagnostics(columns) {
+	return columns.flatMap((column, columnIndex) => column.options.flatMap((option, optionIndex) => {
+		const firstIndex = column.options.findIndex((item) => item.value === option.value);
+		return firstIndex === optionIndex ? [] : [{
+			type: "duplicate-value",
+			columnIndex,
+			optionIndex,
+			firstIndex,
+			value: option.value
+		}];
+	}));
+}
+/** 键盘目标索引：跳过禁用与重复后项；没有可去的项时返回 -1。当前无效时向下类从首项、向上类从末项找。 */
+function getPickerKeyboardTarget(column, current, move) {
+	const count = column.options.length;
+	const scan = (from, step, stop = step > 0 ? count : -1) => {
+		for (let index = from; step > 0 ? index < stop : index > stop; index += step) if (isPickerOptionSelectable(column, index)) return index;
+		return -1;
+	};
+	const valid = current >= 0 && current < count;
+	if (move === "first" || !valid && (move === "next" || move === "page-next")) return scan(0, 1);
+	if (move === "last" || !valid && (move === "previous" || move === "page-previous")) return scan(count - 1, -1);
+	if (move === "next") return scan(current + 1, 1);
+	if (move === "previous") return scan(current - 1, -1);
+	if (move === "page-next") {
+		const target = Math.min(count - 1, current + PAGE_STEP);
+		const forward = scan(target, 1);
+		return forward >= 0 ? forward : scan(target - 1, -1, current);
+	}
+	const target = Math.max(0, current - PAGE_STEP);
+	const backward = scan(target, -1);
+	return backward >= 0 ? backward : scan(target + 1, 1, current);
+}
+function sameColumns(a, b) {
+	return a.length === b.length && a.every((column, index) => {
+		const other = b[index];
+		return column.label === other.label && column.options.length === other.options.length && column.options.every((option, i) => {
+			const next = other.options[i];
+			return option.value === next.value && option.label === next.label && !!option.disabled === !!next.disabled;
+		});
+	});
+}
+function validGeometry(geometry, count) {
+	return Number.isFinite(geometry.viewportHeight) && geometry.viewportHeight > 0 && Number.isFinite(geometry.scrollHeight) && geometry.scrollHeight > 0 && Number.isFinite(geometry.scrollTop) && geometry.rows.length === count && geometry.rows.every((row, index) => Number.isFinite(row.top) && Number.isFinite(row.height) && row.height > 0 && (index === 0 || row.top >= geometry.rows[index - 1].top));
+}
+function nearest(column, geometry) {
+	const center = geometry.scrollTop + geometry.viewportHeight / 2;
+	let result = -1;
+	let distance = Infinity;
+	geometry.rows.forEach((row, index) => {
+		const next = Math.abs(row.top + row.height / 2 - center);
+		if (isPickerOptionSelectable(column, index) && next < distance) {
+			result = index;
+			distance = next;
+		}
+	});
+	return result;
+}
+function snapshotColumns(columns) {
+	return columns.map((column) => ({
+		...column,
+		options: column.options.map((option) => ({ ...option }))
+	}));
+}
+/** Core 选择会话。由 pickerMachine 的 refs 持有；context 中的 snapshot 只是它的可观察投影。 */
+var PickerSelectionModel = class {
+	props;
+	accepted;
+	restore;
+	preview;
+	source = "external";
+	externalInvalid = false;
+	lastUserColumn = -1;
+	columns;
+	epoch = 1;
+	sessionEpoch = 1;
+	active = true;
+	disposed = false;
+	pendingConfirm = false;
+	inlineDirty = false;
+	discreteTimer;
+	ownerTimer;
+	focusedColumn = 0;
+	userRevision = 0;
+	nextCommand = 0;
+	nextGeneration = 0;
+	nextMountEpoch = 0;
+	serviceId;
+	notificationSink;
+	mode;
+	constructor(serviceId, props, notificationSink, mode = "popup") {
+		this.serviceId = serviceId;
+		this.notificationSink = notificationSink;
+		this.mode = mode;
+		this.props = {
+			...props,
+			columns: snapshotColumns(props.columns),
+			...props.value ? { value: [...props.value] } : {}
+		};
+		this.accepted = [...props.value ?? props.defaultValue ?? props.columns.map(getPickerFirstValue)];
+		this.restore = resizeValue(this.accepted, props.columns.length);
+		this.preview = this.restore;
+		this.columns = props.columns.map(() => ({
+			generation: ++this.nextGeneration,
+			mountEpoch: 0,
+			attached: false,
+			user: false,
+			scrolling: false
+		}));
+		this.externalInvalid = props.value !== void 0 && !this.previewValid();
+	}
+	observer;
+	observe(observer) {
+		this.observer = observer;
+		observer(this.snapshot);
+		return () => {
+			if (this.observer === observer) this.observer = void 0;
+		};
+	}
+	publish() {
+		this.observer?.(this.snapshot);
+	}
+	notify(event) {
+		this.publish();
+		this.notificationSink(event);
+	}
+	get isDisposed() {
+		return this.disposed;
+	}
+	get snapshot() {
+		return {
+			mode: this.mode,
+			userRevision: this.userRevision,
+			committed: [...this.accepted],
+			preview: [...this.preview],
+			source: this.source,
+			selectedIndices: this.props.columns.map((column, index) => getPickerOptionIndex(column, this.preview[index] ?? null)),
+			valid: this.valid(),
+			pendingConfirm: this.pendingConfirm,
+			active: this.active,
+			focusedColumn: Math.max(0, Math.min(this.focusedColumn, this.props.columns.length - 1)),
+			tokens: this.columns.map((column, index) => this.active && column.attached ? this.token(index) : void 0),
+			commands: this.columns.flatMap((column) => column.command ? [{
+				...column.command,
+				token: { ...column.command.token }
+			}] : [])
+		};
+	}
+	previewValid() {
+		return this.props.columns.length > 0 && this.props.columns.every((column, index) => getPickerOptionIndex(column, this.preview[index] ?? null) >= 0);
+	}
+	valid() {
+		return this.previewValid() && !this.externalInvalid;
+	}
+	token(columnIndex) {
+		const column = this.columns[columnIndex];
+		return {
+			serviceId: this.serviceId,
+			epoch: this.epoch,
+			columnIndex,
+			generation: column.generation,
+			mountEpoch: column.mountEpoch
+		};
+	}
+	current(token) {
+		const column = this.columns[token.columnIndex];
+		return this.active && column?.attached && token.serviceId === this.serviceId && token.epoch === this.epoch && token.generation === column.generation && token.mountEpoch === column.mountEpoch ? column : void 0;
+	}
+	attach(columnIndex) {
+		try {
+			const column = this.columns[columnIndex];
+			if (!this.active || !column) throw new Error("Inactive selection surface");
+			this.clearTimer(column);
+			column.mountEpoch = ++this.nextMountEpoch;
+			column.attached = true;
+			column.geometry = void 0;
+			column.command = void 0;
+			column.user = false;
+			column.pointer = void 0;
+			return this.token(columnIndex);
+		} finally {
+			this.publish();
+		}
+	}
+	detach(token) {
+		try {
+			const column = this.columns[token.columnIndex];
+			if (this.disposed || !column?.attached || token.serviceId !== this.serviceId || token.mountEpoch !== column.mountEpoch) return;
+			this.clearTimer(column);
+			column.mountEpoch = ++this.nextMountEpoch;
+			column.attached = false;
+			column.geometry = void 0;
+			column.command = void 0;
+			column.scrolling = false;
+			column.pointer = void 0;
+			column.user = false;
+			this.pendingConfirm = false;
+		} finally {
+			this.publish();
+		}
+	}
+	dispatch(token, signal) {
+		try {
+			const column = this.current(token);
+			if (!column) return;
+			if (signal.type === "MEASURE") {
+				if (!validGeometry(signal.geometry, this.props.columns[token.columnIndex].options.length)) {
+					this.clearTimer(column);
+					column.geometry = void 0;
+					column.command = void 0;
+					if (column.scrolling && !column.user && column.pointer === void 0) {
+						column.scrolling = false;
+						if (this.mode === "inline") this.flushInline();
+						else if (this.pendingConfirm && !this.waiting() && this.valid()) this.commit();
+					}
+					return;
+				}
+				column.geometry = {
+					...signal.geometry,
+					rows: signal.geometry.rows.map((row) => ({ ...row }))
+				};
+				if (!this.align(token.columnIndex, "alignment") && column.scrolling) this.schedule(token);
+				return;
+			}
+			if (signal.type === "COMMAND.APPLIED") {
+				if (column.command?.commandId !== signal.commandId || !validGeometry(signal.geometry, this.props.columns[token.columnIndex].options.length)) return;
+				const reason = column.command.reason;
+				column.geometry = {
+					...signal.geometry,
+					rows: signal.geometry.rows.map((row) => ({ ...row }))
+				};
+				column.command = void 0;
+				if (reason === "settlement" && column.user || this.pendingConfirm && column.scrolling) this.schedule(token);
+				return;
+			}
+			if (signal.type === "POINTER.START" || signal.type === "WHEEL") {
+				if (signal.type === "WHEEL" && !Number.isFinite(signal.deltaY)) return;
+				this.userRevision++;
+				column.user = true;
+				column.command = void 0;
+				this.clearTimer(column);
+				if (signal.type === "POINTER.START") {
+					if (column.pointer === void 0) column.pointer = signal.pointerId;
+				} else {
+					column.scrolling = true;
+					if (column.geometry) this.schedule(token);
+				}
+				return;
+			}
+			if (signal.type === "POINTER.END" || signal.type === "POINTER.CANCEL") {
+				if (column.pointer !== signal.pointerId) return;
+				column.pointer = void 0;
+				this.schedule(token);
+				return;
+			}
+			if (signal.type === "SCROLL") {
+				if (!column.geometry || !Number.isFinite(signal.scrollTop)) return;
+				column.geometry = {
+					...column.geometry,
+					scrollTop: signal.scrollTop
+				};
+				if (!column.user) return;
+				column.scrolling = true;
+				const index = nearest(this.props.columns[token.columnIndex], column.geometry);
+				const value = index < 0 ? null : this.props.columns[token.columnIndex].options[index].value;
+				const preview = this.preview.map((item, i) => i === token.columnIndex ? value : item);
+				if (!sameValue(preview, this.preview)) {
+					this.setUserPreview(preview, token.columnIndex);
+					this.notify({
+						type: "preview",
+						value: [...preview]
+					});
+				}
+				if (this.current(token) && column.pointer === void 0) this.schedule(token);
+			}
+		} finally {
+			this.publish();
+		}
+	}
+	/** Captured identity must survive queueing; never relabel an old input. */
+	queue(token, signal) {
+		queueMicrotask(() => this.dispatch(token, signal));
+	}
+	/** 离散选择（点击/键盘）：等同一次立即落定的用户选择；正在滚的本列被它取代。 */
+	select(columnIndex, optionIndex) {
+		try {
+			const column = this.props.columns[columnIndex];
+			const state = this.columns[columnIndex];
+			if (!this.active || this.disposed || !column || !state || !isPickerOptionSelectable(column, optionIndex)) return;
+			this.userRevision++;
+			this.focusedColumn = columnIndex;
+			this.clearTimer(state);
+			state.user = false;
+			state.scrolling = false;
+			state.pointer = void 0;
+			state.command = void 0;
+			const value = column.options[optionIndex].value;
+			const preview = resizeValue(this.preview, this.props.columns.length).map((item, i) => i === columnIndex ? value : item);
+			if (!sameValue(preview, this.preview)) {
+				this.setUserPreview(preview, columnIndex);
+				this.notify({
+					type: "preview",
+					value: [...preview]
+				});
+			}
+			if (!this.active || this.disposed || !this.columns[columnIndex]) return;
+			this.align(columnIndex, "alignment");
+			this.scheduleDiscrete();
+		} finally {
+			this.publish();
+		}
+	}
+	/**
+	* 离散选择的落定：与滚轮相同的静默窗口后才提交（内嵌）或兑现已按下的确定（工具栏）。
+	* 让框架下一次渲染才送达的联动后列先到，避免以旧后列冒充新数据（FR-011）。
+	*/
+	scheduleDiscrete() {
+		if (this.mode !== "inline" && !this.pendingConfirm) return;
+		this.clearDiscrete();
+		const epoch = this.epoch;
+		const sessionEpoch = this.sessionEpoch;
+		this.discreteTimer = setTimeout(() => {
+			this.discreteTimer = void 0;
+			if (!this.active || this.disposed || this.epoch !== epoch || this.sessionEpoch !== sessionEpoch) return;
+			try {
+				if (this.mode === "inline") this.flushInline();
+				else if (this.pendingConfirm && !this.waiting() && this.valid()) this.commit();
+			} finally {
+				this.publish();
+			}
+		}, QUIET_MS);
+	}
+	clearDiscrete() {
+		if (this.discreteTimer !== void 0) clearTimeout(this.discreteTimer);
+		this.discreteTimer = void 0;
+	}
+	/** 列内键盘移动；目标不存在时只更新列焦点。 */
+	move(columnIndex, move) {
+		const column = this.props.columns[columnIndex];
+		if (!this.active || this.disposed || !column) return;
+		const target = getPickerKeyboardTarget(column, getPickerOptionIndex(column, this.preview[columnIndex] ?? null), move);
+		if (target >= 0) this.select(columnIndex, target);
+		else this.focus(columnIndex);
+	}
+	/** 记录逻辑列焦点（roving tabindex）。不发业务通知。 */
+	focus(columnIndex) {
+		if (this.disposed || columnIndex < 0 || columnIndex >= this.props.columns.length || columnIndex === this.focusedColumn) return;
+		this.focusedColumn = columnIndex;
+		this.publish();
+	}
+	setUserPreview(preview, columnIndex) {
+		this.preview = preview;
+		this.source = "user";
+		this.lastUserColumn = columnIndex;
+		if (this.mode === "inline") this.inlineDirty = true;
+	}
+	clearTimer(column) {
+		if (column.timer !== void 0) clearTimeout(column.timer);
+		column.timer = void 0;
+	}
+	schedule(token) {
+		const column = this.current(token);
+		if (!column || column.pointer !== void 0) return;
+		this.clearTimer(column);
+		column.timer = setTimeout(() => {
+			column.timer = void 0;
+			if (!this.current(token) || column.pointer !== void 0) return;
+			this.settle(token);
+			this.publish();
+		}, QUIET_MS);
+	}
+	align(columnIndex, reason) {
+		const column = this.columns[columnIndex];
+		const geometry = column.geometry;
+		const index = getPickerOptionIndex(this.props.columns[columnIndex], this.preview[columnIndex] ?? null);
+		if (!geometry || index < 0) return false;
+		const row = geometry.rows[index];
+		const offset = Math.max(0, Math.min(geometry.scrollHeight - geometry.viewportHeight, row.top + row.height / 2 - geometry.viewportHeight / 2));
+		if (geometry.scrollTop === offset) return false;
+		if (column.command?.offset === offset && column.command.reason === reason) return true;
+		column.command = {
+			token: this.token(columnIndex),
+			commandId: ++this.nextCommand,
+			offset,
+			behavior: "auto",
+			reason
+		};
+		return true;
+	}
+	settle(token) {
+		const column = this.current(token);
+		if (!column?.geometry) return;
+		if (this.align(token.columnIndex, "settlement")) return;
+		column.scrolling = false;
+		if (this.mode === "inline") this.flushInline();
+		else if (this.pendingConfirm && !this.waiting() && this.valid()) this.commit();
+	}
+	waiting() {
+		return this.columns.some((column) => column.pointer !== void 0 || column.scrolling || column.command?.reason === "settlement");
+	}
+	confirm() {
+		try {
+			if (!this.active || !this.valid() || this.mode === "inline") return;
+			if (this.waiting()) {
+				this.pendingConfirm = true;
+				return;
+			}
+			this.commit();
+		} finally {
+			this.publish();
+		}
+	}
+	commit() {
+		this.pendingConfirm = false;
+		const value = resizeValue(this.preview, this.props.columns.length);
+		if (this.props.value === void 0) this.accepted = [...value];
+		this.restore = resizeValue(this.accepted, this.props.columns.length);
+		this.invalidate();
+		const sessionEpoch = this.sessionEpoch;
+		this.notify({
+			type: "value",
+			value: [...value]
+		});
+		this.awaitOwner();
+		if (this.sessionEpoch === sessionEpoch && this.active && !this.disposed) this.notify({
+			type: "close",
+			open: false
+		});
+	}
+	/** 内嵌：所有列落定且有效、并且与已提交值不同，才通知一次 value。不关闭、不使在途输入失效。 */
+	flushInline() {
+		if (this.mode !== "inline" || !this.active || this.disposed || !this.inlineDirty || this.waiting() || !this.valid()) return;
+		this.inlineDirty = false;
+		const value = resizeValue(this.preview, this.props.columns.length);
+		if (sameValue(value, resizeValue(this.accepted, this.props.columns.length))) return;
+		if (this.props.value === void 0) this.accepted = [...value];
+		this.restore = resizeValue(this.accepted, this.props.columns.length);
+		this.notify({
+			type: "value",
+			value: [...value]
+		});
+		this.awaitOwner();
+	}
+	/**
+	* 受控请求发出后：调用方在 OWNER_MS 内没有改写 value（拒绝），且用户未再操作，
+	* 则显示回到调用方的值（同外部回写路径：新代次、桥重新测量并对齐），并通知一次恢复后的预览。
+	* 工具栏若已真实关闭，会话结束即可，重开本就从已提交值开始。
+	*/
+	awaitOwner() {
+		this.clearOwner();
+		if (this.props.value === void 0 || this.disposed || !this.active) return;
+		const requested = [...this.props.value];
+		const revision = this.userRevision;
+		const sessionEpoch = this.sessionEpoch;
+		this.ownerTimer = setTimeout(() => {
+			this.ownerTimer = void 0;
+			if (this.disposed || !this.active || this.sessionEpoch !== sessionEpoch || this.userRevision !== revision || this.props.value === void 0) return;
+			if (!sameValue(this.props.value, requested) || this.waiting()) return;
+			const count = this.props.columns.length;
+			const restored = resizeValue(this.accepted, count);
+			if (sameValue(resizeValue(this.preview, count), restored)) return;
+			try {
+				this.invalidate();
+				this.preview = restored;
+				this.restore = [...restored];
+				this.source = "external";
+				this.externalInvalid = !this.previewValid();
+				this.notify({
+					type: "preview",
+					value: [...restored]
+				});
+			} finally {
+				this.publish();
+			}
+		}, OWNER_MS);
+	}
+	clearOwner() {
+		if (this.ownerTimer !== void 0) clearTimeout(this.ownerTimer);
+		this.ownerTimer = void 0;
+	}
+	cancel(requestClose = true) {
+		try {
+			if (!this.active || this.mode === "inline") return;
+			this.invalidate();
+			this.preview = resizeValue(this.restore, this.props.columns.length);
+			this.source = "restore";
+			const sessionEpoch = this.sessionEpoch;
+			this.notify({
+				type: "preview",
+				value: [...this.preview]
+			});
+			if (requestClose && this.sessionEpoch === sessionEpoch && this.active && !this.disposed) this.notify({
+				type: "close",
+				open: false
+			});
+		} finally {
+			this.publish();
+		}
+	}
+	/** Actual inherited Popup close fact, not another modal state transition. */
+	closed() {
+		try {
+			this.sessionEpoch++;
+			this.invalidate();
+			this.clearOwner();
+			this.active = false;
+			this.source = "external";
+		} finally {
+			this.publish();
+		}
+	}
+	stop() {
+		try {
+			this.sessionEpoch++;
+			this.invalidate();
+			this.clearOwner();
+			this.active = false;
+			this.disposed = true;
+		} finally {
+			this.publish();
+		}
+	}
+	invalidate() {
+		this.epoch++;
+		this.pendingConfirm = false;
+		this.inlineDirty = false;
+		this.clearDiscrete();
+		for (const column of this.columns) {
+			this.clearTimer(column);
+			column.generation = ++this.nextGeneration;
+			column.user = false;
+			column.scrolling = false;
+			column.pointer = void 0;
+			column.command = void 0;
+		}
+	}
+	update(props) {
+		try {
+			if (this.disposed) return;
+			const columnsChanged = !sameColumns(this.props.columns, props.columns);
+			const dependentChanged = props.columns.some((column, index) => index > this.lastUserColumn && (column.options.length !== this.props.columns[index]?.options.length || column.options.some((option, row) => {
+				const previous = this.props.columns[index]?.options[row];
+				return !previous || option.value !== previous.value || !!option.disabled !== !!previous.disabled;
+			})));
+			const externalChanged = props.value !== void 0 && (this.props.value === void 0 || !sameValue(props.value, this.props.value));
+			const controlledRemoved = props.value === void 0 && this.props.value !== void 0;
+			if (columnsChanged) {
+				this.columns.slice(props.columns.length).forEach((column) => this.clearTimer(column));
+				this.columns = props.columns.map((column, index) => {
+					const previous = this.columns[index];
+					const before = this.props.columns[index];
+					if (previous && before && sameColumns([before], [column])) return previous;
+					if (previous) this.clearTimer(previous);
+					return {
+						generation: ++this.nextGeneration,
+						mountEpoch: previous?.mountEpoch ?? 0,
+						attached: previous?.attached ?? false,
+						user: false,
+						scrolling: this.active && this.source === "user" && (previous?.attached ?? false)
+					};
+				});
+			}
+			this.props = {
+				...props,
+				columns: snapshotColumns(props.columns),
+				...props.value ? { value: [...props.value] } : {}
+			};
+			if (externalChanged) {
+				this.invalidate();
+				this.clearOwner();
+				this.accepted = [...props.value];
+				this.preview = resizeValue(this.accepted, props.columns.length);
+				this.source = "external";
+				this.restore = [...this.preview];
+				this.externalInvalid = !this.previewValid();
+			} else if (controlledRemoved) {
+				this.preview = resizeValue(this.accepted, props.columns.length);
+				this.source = "external";
+				this.pendingConfirm = false;
+				this.externalInvalid = false;
+				this.inlineDirty = false;
+			} else if (columnsChanged) {
+				this.preview = resizeValue(this.preview, props.columns.length);
+				if (this.source === "user" && dependentChanged) {
+					const next = this.preview.map((value, index) => index > this.lastUserColumn && getPickerOptionIndex(props.columns[index], value) < 0 ? getPickerFirstValue(props.columns[index]) : value);
+					this.externalInvalid = false;
+					if (!sameValue(next, this.preview)) {
+						this.setUserPreview(next, this.lastUserColumn);
+						this.notify({
+							type: "preview",
+							value: [...next]
+						});
+					}
+					this.flushInline();
+				} else {
+					this.externalInvalid = props.value !== void 0 && props.columns.some((column, index) => getPickerOptionIndex(column, this.accepted[index] ?? null) < 0);
+					if (!this.valid()) this.pendingConfirm = false;
+				}
+			}
+		} finally {
+			this.publish();
+		}
+	}
+	/** Begin a later actual Popup opening from the accepted entry value. */
+	reopened() {
+		try {
+			if (this.disposed) throw new Error("Disposed selection service");
+			this.sessionEpoch++;
+			this.invalidate();
+			this.clearOwner();
+			this.active = true;
+			this.restore = resizeValue(this.accepted, this.props.columns.length);
+			this.preview = [...this.restore];
+			this.source = "external";
+			this.externalInvalid = this.props.value !== void 0 && !this.previewValid();
+		} finally {
+			this.publish();
+		}
+	}
+};
+//#endregion
+//#region src/picker/picker-machine.ts
+const EMPTY_SELECTION = { columns: [] };
+const noRefs = {
+	get: () => {
+		throw new Error("Pinned Popup has no refs");
+	},
+	set: () => {
+		throw new Error("Pinned Popup has no refs");
+	}
+};
+function popupContext(context) {
+	function set(key, value) {
+		context.set(key, value);
+	}
+	return {
+		get: (key) => context.get(key),
+		set,
+		initial: (key) => context.initial(key),
+		hash: (key) => context.hash(key)
+	};
+}
+function isPopupEvent(event) {
+	return !event.type.startsWith("SELECTION.");
+}
+function popupEvent(event) {
+	if (!isPopupEvent(event)) throw new Error("Picker events must not run upstream Popup handlers");
+	return event;
+}
+function popupMetadata(event) {
+	return event;
+}
+function popupParams(params) {
+	return {
+		...params,
+		prop: (key) => params.prop(key),
+		context: popupContext(params.context),
+		refs: noRefs,
+		computed: (key) => params.computed(key),
+		event: popupMetadata(params.event),
+		send: (event) => params.send(event),
+		action: (keys) => params.action(keys),
+		guard: (key) => typeof key === "function" ? key(popupParams(params)) : params.guard(key),
+		choose: () => {
+			throw new Error("Pinned Popup has no inline choose implementation");
+		}
+	};
+}
+function transition(input) {
+	const guard = input.guard;
+	return {
+		...input,
+		guard: (params) => !params.refs.get("selectionModel").isDisposed && (guard === void 0 || (typeof guard === "function" ? guard(popupParams(params)) : params.guard(guard)) === true)
+	};
+}
+function transitions(input) {
+	return Array.isArray(input) ? input.map((item) => transition(item)) : input ? transition(input) : void 0;
+}
+/** A queued selection close carries the actual service session and is re-checked at execution. */
+function selectionClose(input) {
+	const items = transitions(input);
+	return items ? (Array.isArray(items) ? items : [items]).map((item) => ({
+		...item,
+		guard: (params) => params.event.type === "SELECTION.CLOSE" && params.event.session === params.refs.get("selectionTransport").session && (item.guard === void 0 || (typeof item.guard === "function" ? item.guard(params) : params.guard(item.guard)) === true)
+	})) : void 0;
+}
+function state(input) {
+	const { entry, exit, effects, states: nested, ...rest } = input;
+	if (nested) throw new Error("Pinned Popup has no nested states");
+	return {
+		...rest,
+		entry: typeof entry === "function" ? (params) => entry(popupParams(params)) : entry,
+		exit: typeof exit === "function" ? (params) => exit(popupParams(params)) : exit,
+		effects: typeof effects === "function" ? (params) => effects(popupParams(params)) : effects,
+		on: {
+			OPEN: transitions(input.on?.OPEN),
+			CLOSE: transitions(input.on?.CLOSE),
+			"SELECTION.CLOSE": selectionClose(input.on?.CLOSE),
+			TOGGLE: transitions(input.on?.TOGGLE),
+			"CONTROLLED.OPEN": transitions(input.on?.["CONTROLLED.OPEN"]),
+			"CONTROLLED.CLOSE": transitions(input.on?.["CONTROLLED.CLOSE"]),
+			"TRIGGER_VALUE.SET": transitions(input.on?.["TRIGGER_VALUE.SET"])
+		}
+	};
+}
+const closed = state(popupMachine.states.closed);
+/** Inline keeps every inherited opening path closed: no lock, portal, ticket or registration. */
+function onlyPopup(input) {
+	return input ? (Array.isArray(input) ? input : [input]).map((item) => ({
+		...item,
+		guard: (params) => params.refs.get("mode") === "popup" && (item.guard === void 0 || (typeof item.guard === "function" ? item.guard(params) : params.guard(item.guard)) === true)
+	})) : void 0;
+}
+const disposed = (params) => params.refs.get("selectionModel").isDisposed;
+/** Typed pinned upstream projection: one service, the original two modal states. */
+const pickerMachine = {
+	props(params) {
+		return {
+			...popupMachine.props({
+				props: params.props,
+				scope: params.scope
+			}),
+			mode: params.props.mode === "inline" ? "inline" : "popup",
+			selection: params.props.selection,
+			onSelectionNotice: params.props.onSelectionNotice
+		};
+	},
+	initialState(params) {
+		return params.prop("mode") === "inline" ? "closed" : popupMachine.initialState({ prop: (key) => params.prop(key) });
+	},
+	context(params) {
+		return {
+			...popupMachine.context({
+				...params,
+				prop: (key) => params.prop(key),
+				getContext: () => popupContext(params.getContext()),
+				getComputed: () => (key) => params.getComputed()(key),
+				getRefs: () => noRefs,
+				getEvent: () => popupEvent(params.getEvent())
+			}),
+			preview: params.bindable(() => ({ defaultValue: [] })),
+			selectionSnapshot: params.bindable(() => ({ defaultValue: null })),
+			surfaceTokens: params.bindable(() => ({ defaultValue: [] }))
+		};
+	},
+	refs({ prop }) {
+		const mode = prop("mode");
+		const selectionTransport = {
+			closeIntent: false,
+			session: 0
+		};
+		const selectionModel = new PickerSelectionModel(prop("id") ?? "", prop("selection") ?? EMPTY_SELECTION, (event) => selectionTransport.notice?.(event), mode);
+		if (mode === "popup" && !(prop("open") ?? prop("defaultOpen"))) selectionModel.closed();
+		return {
+			mode,
+			selectionModel,
+			selectionTransport
+		};
+	},
+	entry: (params) => typeof popupMachine.entry === "function" ? popupMachine.entry(popupParams(params)) : popupMachine.entry,
+	exit: (params) => typeof popupMachine.exit === "function" ? popupMachine.exit(popupParams(params)) : popupMachine.exit,
+	effects: ["selectionLifetime"],
+	watch(params) {
+		popupMachine.watch?.(popupParams(params));
+		params.track([() => JSON.stringify(params.prop("selection"))], () => {
+			params.refs.get("selectionModel").update(params.prop("selection") ?? EMPTY_SELECTION);
+		});
+	},
+	states: {
+		open: {
+			...state(popupMachine.states.open),
+			entry(params) {
+				if (disposed(params)) return;
+				params.refs.get("selectionTransport").session++;
+				params.refs.get("selectionModel").reopened();
+				const entry = popupMachine.states.open.entry;
+				return typeof entry === "function" ? entry(popupParams(params)) : entry;
+			},
+			exit(params) {
+				const model = params.refs.get("selectionModel");
+				const transport = params.refs.get("selectionTransport");
+				transport.session++;
+				if (model.snapshot.active && !transport.closeIntent) model.cancel(false);
+				model.closed();
+				transport.closeIntent = false;
+				const exit = popupMachine.states.open.exit;
+				return typeof exit === "function" ? exit(popupParams(params)) : exit;
+			}
+		},
+		closed: {
+			...closed,
+			on: {
+				...closed.on,
+				OPEN: onlyPopup(closed.on?.OPEN),
+				TOGGLE: onlyPopup(closed.on?.TOGGLE),
+				"CONTROLLED.OPEN": onlyPopup(closed.on?.["CONTROLLED.OPEN"])
+			}
+		}
+	},
+	on: {
+		"SELECTION.MOUNT": { actions: ["selectionInput"] },
+		"SELECTION.UNMOUNT": { actions: ["selectionInput"] },
+		"SELECTION.INPUT": { actions: ["selectionInput"] },
+		"SELECTION.SELECT": { actions: ["selectionInput"] },
+		"SELECTION.MOVE": { actions: ["selectionInput"] },
+		"SELECTION.FOCUS": { actions: ["selectionInput"] },
+		"SELECTION.CONFIRM": { actions: ["selectionInput"] },
+		"SELECTION.CANCEL": { actions: ["selectionInput"] }
+	},
+	implementations: {
+		guards: { isOpenControlled: (params) => popupMachine.implementations.guards.isOpenControlled(popupParams(params)) },
+		effects: {
+			selectionLifetime(params) {
+				const model = params.refs.get("selectionModel");
+				const transport = params.refs.get("selectionTransport");
+				const releaseClose = onModalBeforeClose(params, () => {
+					if (model.snapshot.active && !transport.closeIntent) {
+						model.cancel(false);
+						transport.closeIntent = true;
+					}
+				});
+				let userRevision = model.snapshot.userRevision;
+				const unobserve = model.observe((snapshot) => {
+					if (snapshot.userRevision !== userRevision) transport.closeIntent = false;
+					userRevision = snapshot.userRevision;
+					params.context.set("selectionSnapshot", snapshot);
+					params.context.set("preview", snapshot.preview);
+					params.context.set("surfaceTokens", snapshot.tokens);
+				});
+				transport.notice = (event) => {
+					const session = transport.session;
+					params.prop("onSelectionNotice")?.(event);
+					if (event.type === "close" && model.snapshot.active && session === transport.session) {
+						transport.closeIntent = true;
+						modalRequestSend({
+							...popupParams(params),
+							send: (event) => params.send({
+								...event,
+								type: "SELECTION.CLOSE",
+								session
+							})
+						})({ type: "CLOSE" });
+					}
+				};
+				return () => {
+					releaseClose();
+					selectionPending.delete(model);
+					transport.session++;
+					transport.notice = void 0;
+					model.stop();
+					unobserve();
+				};
+			},
+			trackDismissableElement: (params) => disposed(params) ? void 0 : popupMachine.implementations.effects.trackDismissableElement(popupParams(params)),
+			trapFocus: (params) => disposed(params) ? void 0 : popupMachine.implementations.effects.trapFocus(popupParams(params)),
+			preventScroll: (params) => disposed(params) ? void 0 : popupMachine.implementations.effects.preventScroll(popupParams(params)),
+			hideContentBelow: (params) => disposed(params) ? void 0 : popupMachine.implementations.effects.hideContentBelow(popupParams(params))
+		},
+		actions: {
+			checkRenderedElements: (params) => disposed(params) ? void 0 : popupMachine.implementations.actions.checkRenderedElements(popupParams(params)),
+			setInitialFocus: (params) => disposed(params) ? void 0 : popupMachine.implementations.actions.setInitialFocus(popupParams(params)),
+			invokeOnClose(params) {
+				const model = params.refs.get("selectionModel");
+				const transport = params.refs.get("selectionTransport");
+				if (model.snapshot.active && !transport.closeIntent) {
+					model.cancel(false);
+					transport.closeIntent = true;
+				}
+				if (!model.isDisposed) popupMachine.implementations.actions.invokeOnClose(popupParams(params));
+			},
+			invokeOnOpen: (params) => disposed(params) ? void 0 : popupMachine.implementations.actions.invokeOnOpen(popupParams(params)),
+			toggleVisibility: (params) => disposed(params) ? void 0 : popupMachine.implementations.actions.toggleVisibility(popupParams(params)),
+			setTriggerValue: (params) => {
+				if (disposed(params)) return;
+				popupEvent(params.event);
+				popupMachine.implementations.actions.setTriggerValue(popupParams(params));
+			},
+			selectionInput(params) {
+				const ticket = params.event[selectionTicket];
+				if (ticket) {
+					if (ticket.processed) return;
+					ticket.processed = true;
+					const pending = selectionPending.get(params.refs.get("selectionModel"));
+					if (pending) pending.splice(pending.indexOf(ticket), 1);
+				}
+				requestPickerSelection(params);
+			}
+		}
+	}
+};
+/** Project the one service for the upstream Popup connector; never instantiate another. */
+function toPopupService(service) {
+	return {
+		...service,
+		context: popupContext(service.context),
+		prop: (key) => service.prop(key),
+		refs: noRefs,
+		computed: (key) => service.computed(key),
+		send: (event) => service.send(event),
+		event: popupMetadata(service.event)
+	};
+}
+function requestPickerSelection({ event, refs }) {
+	const model = refs.get("selectionModel");
+	if (event.type === "SELECTION.UNMOUNT") {
+		model.detach(event.token);
+		return;
+	}
+	if (!model.snapshot.active) return;
+	if (event.type === "SELECTION.MOUNT") model.attach(event.columnIndex);
+	else if (event.type === "SELECTION.INPUT") model.dispatch(event.token, event.signal);
+	else if (event.type === "SELECTION.SELECT") model.select(event.columnIndex, event.optionIndex);
+	else if (event.type === "SELECTION.MOVE") model.move(event.columnIndex, event.move);
+	else if (event.type === "SELECTION.FOCUS") model.focus(event.columnIndex);
+	else if (event.type === "SELECTION.CONFIRM") model.confirm();
+	else if (event.type === "SELECTION.CANCEL") model.cancel();
+}
+const selectionTicket = Symbol("qw-picker-input");
+const selectionPending = /* @__PURE__ */ new WeakMap();
+/** Keep input ordering when the machine scheduler has not consumed an earlier selection yet. */
+function sendPickerSelection(service, event) {
+	if (service.getStatus() === MachineStatus.Stopped || service.refs.get("selectionModel").isDisposed) return;
+	if (service.getStatus() === MachineStatus.NotStarted) {
+		service.send(event);
+		return;
+	}
+	if (service.refs.get("mode") === "inline") {
+		service.send(event);
+		return;
+	}
+	if (event.type === "SELECTION.CONFIRM" || event.type === "SELECTION.CANCEL") {
+		const pending = selectionPending.get(service.refs.get("selectionModel"));
+		if (pending) while (pending.length) {
+			const ticket = pending.shift();
+			if (ticket.processed) continue;
+			ticket.processed = true;
+			requestPickerSelection({
+				refs: service.refs,
+				event: ticket.event
+			});
+		}
+		requestPickerSelection({
+			refs: service.refs,
+			event
+		});
+		return;
+	}
+	const ticket = {
+		event,
+		processed: false
+	};
+	let pending = selectionPending.get(service.refs.get("selectionModel"));
+	if (!pending) {
+		pending = [];
+		selectionPending.set(service.refs.get("selectionModel"), pending);
+	}
+	pending.push(ticket);
+	const envelope = {
+		...event,
+		[selectionTicket]: ticket
+	};
+	service.send(envelope);
+}
+//#endregion
+//#region src/picker/selection-connect.ts
+/**
+* 机械连接层（包内）：同一 service 投影给原 Popup connector，选择输入保留 typed 队列；confirm/cancel 同步排空先前输入再请求关闭。
+* 原生 IO 只运输捕获的票据与原始信号。connectPicker 在其上增加 ARIA/工具栏 getters。
+*/
+function connectSelection(service, normalize, popupProps, runtime) {
+	const model = service.refs.get("selectionModel");
+	return {
+		popup: connectPopup(toPopupService(service), normalize, popupProps, runtime),
+		snapshot: service.context.get("selectionSnapshot") ?? model.snapshot,
+		mountColumn(columnIndex) {
+			sendPickerSelection(service, {
+				type: "SELECTION.MOUNT",
+				columnIndex
+			});
+		},
+		getColumnToken(columnIndex) {
+			return model.snapshot.tokens[columnIndex];
+		},
+		unmountColumn(token) {
+			sendPickerSelection(service, {
+				type: "SELECTION.UNMOUNT",
+				token
+			});
+		},
+		input(token, signal) {
+			sendPickerSelection(service, {
+				type: "SELECTION.INPUT",
+				token,
+				signal
+			});
+		},
+		select(columnIndex, optionIndex) {
+			sendPickerSelection(service, {
+				type: "SELECTION.SELECT",
+				columnIndex,
+				optionIndex
+			});
+		},
+		move(columnIndex, move) {
+			sendPickerSelection(service, {
+				type: "SELECTION.MOVE",
+				columnIndex,
+				move
+			});
+		},
+		focusColumn(columnIndex) {
+			sendPickerSelection(service, {
+				type: "SELECTION.FOCUS",
+				columnIndex
+			});
+		},
+		confirm() {
+			sendPickerSelection(service, { type: "SELECTION.CONFIRM" });
+		},
+		cancel() {
+			sendPickerSelection(service, { type: "SELECTION.CANCEL" });
+		}
+	};
+}
+//#endregion
+//#region src/picker/picker.ts
+const FALLBACK_NAME = "选择器";
+const CONFIRM_LABEL = "确定";
+const CANCEL_LABEL = "取消";
+const text = (value) => {
+	const normalized = typeof value === "string" ? value.trim() : void 0;
+	return normalized ? normalized : void 0;
+};
+/** 未知 mode 回退 popup。 */
+function resolvePickerMode(mode) {
+	return mode === "inline" ? "inline" : "popup";
+}
+/** 可访问名称：title → ariaLabel → 「选择器」。空白视为缺省。 */
+function getPickerAccessibleName(props) {
+	return text(props.title) ?? text(props.ariaLabel) ?? FALLBACK_NAME;
+}
+/** 业务值只接受 string/null 数组。 */
+function isPickerValue(value) {
+	return Array.isArray(value) && value.every((item) => item === null || typeof item === "string");
+}
+/** 列结构校验：label 可选字符串，options 的 value/label 为字符串，disabled 可选布尔。 */
+function isPickerColumns(value) {
+	return Array.isArray(value) && value.every((column) => {
+		if (typeof column !== "object" || column === null) return false;
+		const { label, options } = column;
+		return (label === void 0 || typeof label === "string") && Array.isArray(options) && options.every((option) => {
+			if (typeof option !== "object" || option === null) return false;
+			const entry = option;
+			return typeof entry.value === "string" && typeof entry.label === "string" && (entry.disabled === void 0 || typeof entry.disabled === "boolean");
+		});
+	});
+}
+/** 渲染数据：保留全部可见项，标出禁用/重复后项与当前预览项。 */
+function resolvePickerColumns(columns, preview = []) {
+	return columns.map((column, index) => {
+		const selectedIndex = getPickerOptionIndex(column, preview[index] ?? null);
+		const options = column.options.map((option, optionIndex) => {
+			const duplicate = column.options.findIndex((item) => item.value === option.value) !== optionIndex;
+			return {
+				index: optionIndex,
+				value: option.value,
+				label: option.label,
+				duplicate,
+				disabled: !isPickerOptionSelectable(column, optionIndex),
+				selected: optionIndex === selectedIndex
+			};
+		});
+		return {
+			index,
+			label: text(column.label) ?? `第 ${index + 1} 列`,
+			options,
+			selectedIndex,
+			empty: options.every((option) => option.disabled)
+		};
+	});
+}
+/** Popup 的 data 属性（placement 固定 bottom）。 */
+function getPickerDataAttrs(props) {
+	return {
+		"data-placement": "bottom",
+		"data-safe-area": props.safeArea === false ? void 0 : ""
+	};
+}
+function toPopupProps(props, mode) {
+	const { mode: _mode, columns: _columns, value: _value, defaultValue: _defaultValue, confirmLabel: _confirm, cancelLabel: _cancel, onValueChange: _onValue, onPreviewChange: _onPreview, ...rest } = props;
+	const popup = {
+		...rest,
+		placement: "bottom"
+	};
+	if (mode === "inline") {
+		delete popup.open;
+		popup.defaultOpen = false;
+	}
+	if (!text(props.title)) popup.ariaLabel = getPickerAccessibleName(props);
+	return popup;
+}
+/** 只接受 popup 物理票据；有限 owner 只能缺省（React/Vue）或 "wc:picker"（qw-picker 宿主）。 */
+function pickerRuntime(mode, runtime) {
+	if (mode === "inline" || !runtime) return void 0;
+	const { kind, owner } = runtime.ticket;
+	if (kind !== "popup" || owner !== void 0 && owner !== "wc:picker") throw new TypeError("Picker requires a popup modal ticket owned by wc:picker or unowned");
+	return runtime;
+}
+/**
+* 公开 props → 同一 pickerMachine 的 props。机械委托 createPopupProps(props, runtime)：
+* 受控优先、初态许可/拒绝仍由 Popup Core 决定；runtime 只在工具栏形态透传（WC 带 owner "wc:picker"）。
+*/
+function createPickerProps(props, runtime) {
+	const columns = props.columns ?? [];
+	if (!isPickerColumns(columns)) throw new TypeError("Picker columns must be an array of { label?, options: { value, label, disabled? }[] }");
+	if (props.value !== void 0 && !isPickerValue(props.value)) throw new TypeError("Picker value must be an array of string | null");
+	if (props.defaultValue !== void 0 && !isPickerValue(props.defaultValue)) throw new TypeError("Picker defaultValue must be an array of string | null");
+	const mode = resolvePickerMode(props.mode);
+	return {
+		...createPopupProps(toPopupProps(props, mode), pickerRuntime(mode, runtime)),
+		mode,
+		selection: {
+			columns,
+			value: props.value,
+			defaultValue: props.defaultValue
+		},
+		onSelectionNotice(notice) {
+			if (notice.type === "preview") props.onPreviewChange?.({ value: notice.value });
+			else if (notice.type === "value") props.onValueChange?.({ value: notice.value });
+		}
+	};
+}
+const VERTICAL = {
+	ArrowDown: "next",
+	ArrowUp: "previous",
+	Home: "first",
+	End: "last",
+	PageDown: "page-next",
+	PageUp: "page-previous"
+};
+/** 物理方向只取渲染树上最近的 dir；逻辑列序不变。 */
+function isRtl(target) {
+	return target?.closest?.("[dir]")?.getAttribute?.("dir")?.toLowerCase() === "rtl";
+}
+function focusSibling(target, index) {
+	target?.closest?.("[data-scope=\"picker\"][data-part=\"columns\"]")?.querySelector?.(`[data-scope="picker"][data-part="column"][data-index="${index}"]`)?.focus?.({ preventScroll: true });
+}
+/**
+* 包装同一 service 的 connectPopup：继承开合/getters 与单层模态拒绝，增加滚轮 root/column/option、
+* 工具栏 cancel/confirm getters。确定/取消/键盘/点击都只发 typed 事件，由 selection-model 决定结果。
+*/
+function connectPicker(service, normalize, props, runtime) {
+	const mode = service.refs.get("mode");
+	const selection = connectSelection(service, normalize, toPopupProps(props, mode), pickerRuntime(mode, runtime));
+	const snapshot = selection.snapshot;
+	const sourceColumns = service.prop("selection")?.columns ?? [];
+	const columns = resolvePickerColumns(sourceColumns, snapshot.preview);
+	const base = `picker:${service.scope.id ?? ""}`;
+	const columnId = (index) => `${base}:column:${index}`;
+	const optionId = (column, option) => `${base}:column:${column}:option:${option}`;
+	const accessibleName = getPickerAccessibleName(props);
+	const inline = mode === "inline";
+	const part = (name) => ({
+		"data-scope": "picker",
+		"data-part": name
+	});
+	return {
+		...selection.popup,
+		mode,
+		columns,
+		value: snapshot.committed,
+		preview: snapshot.preview,
+		valid: snapshot.valid,
+		pendingConfirm: snapshot.pendingConfirm,
+		active: snapshot.active,
+		focusedColumn: snapshot.focusedColumn,
+		selectedIndices: snapshot.selectedIndices,
+		commands: snapshot.commands,
+		diagnostics: getPickerDiagnostics(sourceColumns),
+		accessibleName,
+		confirmLabel: text(props.confirmLabel) ?? CONFIRM_LABEL,
+		cancelLabel: text(props.cancelLabel) ?? CANCEL_LABEL,
+		confirm: selection.confirm,
+		cancel: selection.cancel,
+		selectOption: selection.select,
+		moveColumn: selection.move,
+		mountColumn: selection.mountColumn,
+		getColumnToken: selection.getColumnToken,
+		unmountColumn: selection.unmountColumn,
+		input: selection.input,
+		getRootProps: () => normalize.element({
+			...part("root"),
+			id: `${base}:root`,
+			"data-visual-target": inline ? "picker-inline" : "picker-wheel",
+			"data-mode": mode,
+			"data-valid": snapshot.valid ? "" : void 0,
+			"data-pending": snapshot.pendingConfirm ? "" : void 0,
+			role: inline ? "group" : void 0,
+			"aria-label": inline ? accessibleName : void 0
+		}),
+		getColumnsProps: () => normalize.element({
+			...part("columns"),
+			"data-count": columns.length,
+			"data-empty": columns.length === 0 ? "" : void 0
+		}),
+		getColumnProps({ index }) {
+			const column = columns[index];
+			const selected = column?.selectedIndex ?? -1;
+			return normalize.element({
+				...part("column"),
+				"data-visual-target": "picker-column",
+				"data-index": index,
+				id: columnId(index),
+				role: "listbox",
+				"aria-orientation": "vertical",
+				"aria-label": column?.label ?? `第 ${index + 1} 列`,
+				"aria-activedescendant": selected >= 0 ? optionId(index, selected) : void 0,
+				"aria-disabled": !column || column.empty ? true : void 0,
+				"data-empty": !column || column.empty ? "" : void 0,
+				"data-invalid": selected < 0 ? "" : void 0,
+				"data-focused": snapshot.focusedColumn === index ? "" : void 0,
+				tabIndex: snapshot.focusedColumn === index ? 0 : -1,
+				onFocus() {
+					if (snapshot.focusedColumn !== index) selection.focusColumn(index);
+				},
+				onKeyDown(event) {
+					if (event.defaultPrevented || event.altKey || event.ctrlKey || event.metaKey || event.isComposing) return;
+					const move = VERTICAL[event.key];
+					if (move) {
+						event.preventDefault();
+						selection.move(index, move);
+						return;
+					}
+					if (event.key !== "ArrowLeft" && event.key !== "ArrowRight") return;
+					event.preventDefault();
+					const forward = event.key === "ArrowRight" !== isRtl(event.currentTarget);
+					const next = Math.max(0, Math.min(columns.length - 1, index + (forward ? 1 : -1)));
+					if (next === index) return;
+					selection.focusColumn(next);
+					focusSibling(event.currentTarget, next);
+				}
+			});
+		},
+		getOptionProps({ columnIndex, index }) {
+			const option = columns[columnIndex]?.options[index];
+			if (!option) return normalize.element({
+				...part("option"),
+				role: "option",
+				"aria-selected": false,
+				"aria-disabled": true,
+				"data-disabled": ""
+			});
+			return normalize.element({
+				...part("option"),
+				"data-visual-target": "picker-option",
+				"data-index": index,
+				"data-value": option.value,
+				id: optionId(columnIndex, index),
+				role: "option",
+				"aria-selected": option.selected,
+				"aria-disabled": option.disabled ? true : void 0,
+				"data-selected": option.selected ? "" : void 0,
+				"data-disabled": option.disabled ? "" : void 0,
+				"data-duplicate": option.duplicate ? "" : void 0,
+				onClick() {
+					if (!option.disabled) selection.select(columnIndex, index);
+				}
+			});
+		},
+		getIndicatorProps: () => normalize.element({
+			...part("indicator"),
+			"aria-hidden": true
+		}),
+		getToolbarProps: () => normalize.element({
+			...part("toolbar"),
+			"data-visual-target": "picker-toolbar"
+		}),
+		getCancelProps: () => normalize.element({
+			...part("cancel"),
+			"data-visual-target": "picker-cancel",
+			id: `${base}:cancel`,
+			type: "button",
+			onClick: () => selection.cancel()
+		}),
+		getConfirmProps: () => normalize.element({
+			...part("confirm"),
+			"data-visual-target": "picker-confirm",
+			id: `${base}:confirm`,
+			type: "button",
+			disabled: !snapshot.valid,
+			"data-pending": snapshot.pendingConfirm ? "" : void 0,
+			onClick: () => selection.confirm()
+		})
+	};
+}
+//#endregion
+//#region src/picker/platform.ts
+const sameToken = (a, b) => a.serviceId === b.serviceId && a.epoch === b.epoch && a.columnIndex === b.columnIndex && a.generation === b.generation && a.mountEpoch === b.mountEpoch;
+const sameMount = (a, b) => a.serviceId === b.serviceId && a.columnIndex === b.columnIndex && a.mountEpoch === b.mountEpoch;
+/** Private mechanical resources only. Option/settlement/selection policy remains in Core. */
+function createBinding(viewport, token, rows, sink, physical) {
+	const view = viewport.ownerDocument.defaultView;
+	if (!view) throw new Error("Column requires its owner window");
+	const captured = { ...token };
+	let bound = true;
+	let lastCommandId;
+	const resources = [];
+	const releaseResources = () => {
+		if (!bound) return [];
+		bound = false;
+		const errors = [];
+		for (const release of resources.splice(0).reverse()) try {
+			release();
+		} catch (error) {
+			errors.push(error);
+		}
+		return errors;
+	};
+	const emitRaw = (notice) => {
+		if (physical.active()) sink(notice);
+	};
+	const measure = () => {
+		const box = viewport.getBoundingClientRect();
+		return {
+			viewportHeight: viewport.clientHeight,
+			scrollTop: viewport.scrollTop,
+			scrollHeight: viewport.scrollHeight,
+			rows: rows.map((row) => {
+				const rect = row.getBoundingClientRect();
+				return {
+					top: rect.top - box.top - viewport.clientTop + viewport.scrollTop,
+					height: rect.height
+				};
+			})
+		};
+	};
+	const measureOwned = () => bound && physical.active() ? measure() : void 0;
+	const measured = () => {
+		const geometry = measureOwned();
+		if (geometry) emitRaw({
+			type: "INPUT",
+			token: captured,
+			signal: {
+				type: "MEASURE",
+				geometry
+			},
+			sampledAt: view.performance.now()
+		});
+	};
+	const facts = (event) => ({
+		type: event.type,
+		timeStamp: event.timeStamp,
+		isTrusted: event.isTrusted
+	});
+	const pointer = (event) => ({
+		...facts(event),
+		pointerId: event.pointerId,
+		pointerType: event.pointerType,
+		clientX: event.clientX,
+		clientY: event.clientY
+	});
+	const listeners = [
+		["scroll", (event) => emitRaw({
+			type: "INPUT",
+			token: captured,
+			signal: {
+				type: "SCROLL",
+				scrollTop: viewport.scrollTop,
+				...lastCommandId === void 0 ? {} : { lastCommandId }
+			},
+			event: facts(event)
+		})],
+		["wheel", (event) => {
+			const e = event;
+			emitRaw({
+				type: "INPUT",
+				token: captured,
+				signal: {
+					type: "WHEEL",
+					deltaY: e.deltaY
+				},
+				event: {
+					...facts(e),
+					deltaX: e.deltaX,
+					deltaY: e.deltaY,
+					deltaMode: e.deltaMode
+				}
+			});
+		}],
+		...[
+			"pointerdown",
+			"pointerup",
+			"pointercancel"
+		].map((type) => [type, ((event) => {
+			const e = event;
+			emitRaw({
+				type: "INPUT",
+				token: captured,
+				signal: {
+					type: type === "pointerdown" ? "POINTER.START" : type === "pointerup" ? "POINTER.END" : "POINTER.CANCEL",
+					pointerId: e.pointerId
+				},
+				event: pointer(e)
+			});
+		})]),
+		["pointermove", (event) => emitRaw({
+			type: "RAW.POINTER.MOVE",
+			token: captured,
+			event: pointer(event)
+		})]
+	];
+	try {
+		for (const [type, listener] of listeners) {
+			resources.push(() => viewport.removeEventListener(type, listener));
+			viewport.addEventListener(type, listener, { passive: true });
+		}
+		if (typeof view.ResizeObserver === "function") {
+			const resize = new view.ResizeObserver(measured);
+			resources.push(() => resize.disconnect());
+			resize.observe(viewport);
+			for (const row of rows) resize.observe(row);
+		}
+		if (typeof view.IntersectionObserver === "function") {
+			const intersect = new view.IntersectionObserver(measured);
+			resources.push(() => intersect.disconnect());
+			intersect.observe(viewport);
+		}
+		const fonts = viewport.ownerDocument.fonts;
+		if (fonts) {
+			resources.push(() => fonts.removeEventListener("loadingdone", measured));
+			fonts.addEventListener("loadingdone", measured);
+			if (fonts.ready) fonts.ready.then(measured);
+		}
+	} catch (error) {
+		releaseResources();
+		throw error;
+	}
+	return {
+		measureOwned,
+		rollback() {
+			releaseResources();
+		},
+		release() {
+			const errors = releaseResources();
+			if (errors.length) throw errors[0];
+		},
+		execute(request) {
+			const input = request.type === "SCROLL_TO" ? request.command.token : request.token;
+			if (!bound || !physical.active() || !sameToken(captured, input)) {
+				if (request.type === "SCROLL_TO") emitRaw({
+					type: "COMMAND.FAILED",
+					token: input,
+					commandId: request.command.commandId,
+					reason: "unbound"
+				});
+				return false;
+			}
+			if (request.type === "MEASURE") {
+				measured();
+				return true;
+			}
+			if (request.type === "FOCUS_COLUMN") {
+				viewport.focus({ preventScroll: true });
+				return true;
+			}
+			const command = request.command;
+			if (command.commandId === lastCommandId) return true;
+			const previous = lastCommandId;
+			lastCommandId = command.commandId;
+			let geometry;
+			try {
+				viewport.scrollTo({
+					top: command.offset,
+					behavior: command.behavior
+				});
+				geometry = physical.measureCurrent();
+			} catch {
+				if (lastCommandId === command.commandId) lastCommandId = previous;
+				emitRaw({
+					type: "COMMAND.FAILED",
+					token: captured,
+					commandId: command.commandId,
+					reason: "exception"
+				});
+				return false;
+			}
+			if (!geometry) {
+				emitRaw({
+					type: "COMMAND.FAILED",
+					token: captured,
+					commandId: command.commandId,
+					reason: "unbound"
+				});
+				return false;
+			}
+			emitRaw({
+				type: "INPUT",
+				token: captured,
+				signal: {
+					type: "COMMAND.APPLIED",
+					commandId: command.commandId,
+					geometry
+				},
+				sampledAt: view.performance.now()
+			});
+			return true;
+		}
+	};
+}
+/**
+* 一个物理列挂载：先按 Core 票据校验物理归属，再替换可换的输入绑定。
+* 票据刷新（epoch/generation）只换 binding；真实卸载才 dispose 并送 SURFACE.DETACHED。
+*/
+function attachPickerColumn(viewport, initial, rows, sink) {
+	const physicalOwner = { ...initial };
+	let active = true;
+	let current;
+	const physical = {
+		active: () => active,
+		measureCurrent: () => current?.measureOwned()
+	};
+	const first = createBinding(viewport, initial, rows, sink, physical);
+	current = first;
+	try {
+		sink({
+			type: "SURFACE.MOUNTED",
+			token: physicalOwner
+		});
+		first.execute({
+			type: "MEASURE",
+			token: initial
+		});
+	} catch (error) {
+		active = false;
+		first.rollback();
+		throw error;
+	}
+	return {
+		get binding() {
+			if (!current) throw new Error("No physical binding");
+			return current;
+		},
+		bind(token, nextRows) {
+			if (!sameMount(physicalOwner, token)) throw new Error("Binding does not belong to this physical mount");
+			if (!active) throw new Error("Cannot bind a detached physical surface");
+			const previous = current;
+			previous?.release();
+			let own;
+			try {
+				own = createBinding(viewport, token, nextRows, sink, physical);
+				current = own;
+				own.execute({
+					type: "MEASURE",
+					token
+				});
+				return own;
+			} catch (error) {
+				own?.rollback();
+				if (own && current === own) current = previous;
+				throw error;
+			}
+		},
+		dispose() {
+			if (!active) return;
+			active = false;
+			const errors = [];
+			try {
+				current?.release();
+			} catch (error) {
+				errors.push(error);
+			}
+			try {
+				sink({
+					type: "SURFACE.DETACHED",
+					token: physicalOwner
+				});
+			} catch (error) {
+				errors.push(error);
+			}
+			if (errors.length) throw errors[0];
+		}
+	};
+}
+/**
+* 三栈共用的列生命周期胶水。getHost 每次返回最新 api（React/Vue/WC 每次渲染都会 connect 一次）。
+* Core 未签发票据（工具栏关闭、会话失效）时保持物理挂载但不输入；票据回来后只换绑定。
+*/
+function connectPickerColumn(getHost, viewport, columnIndex, getRows) {
+	let surface;
+	let owner;
+	let bound;
+	let boundRows = [];
+	let disposed = false;
+	const sink = (notice) => {
+		if (notice.type === "INPUT") getHost().input(notice.token, notice.signal);
+		else if (notice.type === "SURFACE.DETACHED") getHost().unmountColumn(notice.token);
+	};
+	const sameRows = (a, b) => a.length === b.length && a.every((row, index) => row === b[index]);
+	const release = () => {
+		const previous = surface;
+		surface = void 0;
+		owner = void 0;
+		bound = void 0;
+		boundRows = [];
+		previous?.dispose();
+	};
+	return {
+		sync() {
+			if (disposed) return;
+			let token = getHost().getColumnToken(columnIndex);
+			if (token && owner && !sameMount(token, owner)) release();
+			if (!surface) {
+				if (!token) {
+					getHost().mountColumn(columnIndex);
+					token = getHost().getColumnToken(columnIndex);
+				}
+				if (!token) return;
+				const rows = getRows();
+				surface = attachPickerColumn(viewport, token, rows, sink);
+				owner = token;
+				bound = token;
+				boundRows = rows;
+			} else if (token) {
+				const rows = getRows();
+				if (!bound || !sameToken(token, bound) || !sameRows(rows, boundRows)) {
+					surface.bind(token, rows);
+					bound = token;
+					boundRows = rows;
+				}
+			}
+			if (!token || !surface || !bound) return;
+			for (const command of getHost().commands) if (sameToken(command.token, bound)) surface.binding.execute({
+				type: "SCROLL_TO",
+				command
+			});
+		},
+		dispose() {
+			if (disposed) return;
+			disposed = true;
+			release();
+		}
+	};
+}
+//#endregion
+export { isPickerOptionSelectable as _, getPickerAccessibleName as a, isPickerValue as c, pickerMachine as d, PickerSelectionModel as f, getPickerOptionIndex as g, getPickerKeyboardTarget as h, createPickerProps as i, resolvePickerColumns as l, getPickerFirstValue as m, connectPickerColumn as n, getPickerDataAttrs as o, getPickerDiagnostics as p, connectPicker as r, isPickerColumns as s, attachPickerColumn as t, resolvePickerMode as u };
+
+//# sourceMappingURL=picker-BykFntQN.js.map