foldkit-primitives 0.15.3 → 0.16.0

package/dist/device/media-stream.js

@@ -0,0 +1,106 @@
+import { Effect, Option, Schema } from "effect";
+import { defineMessageUnion } from "foldkit/message";
+import { Bundle } from "foldkit-bundle";
+import { unlessSame } from "../internal.js";
+import * as ManagedResource from "foldkit/managedResource";
+// src/device/media-stream.ts
+const MediaStreamModel = Schema.Struct({
+	status: Schema.Literals([
+		"idle",
+		"requesting",
+		"live",
+		"denied"
+	]),
+	lastError: Schema.OptionFromNullOr(Schema.String)
+});
+const MediaStreamMessage = defineMessageUnion({
+	Started: {},
+	Stopped: {},
+	Live: {},
+	Ended: {},
+	Denied: {},
+	Failed: { message: Schema.String }
+});
+/** The live stream, for commands that attach it to an element. One assembly holds one. */
+const LiveStream = ManagedResource.tag()("media-stream");
+const failMessage = (error) => error instanceof Error ? error.message : String(error);
+const isDenied = (error) => typeof error?.name === "string" && ["NotAllowedError", "SecurityError"].includes(error.name);
+/**
+* A camera/mic stream as a bundle factory: one live MediaStream held in a
+* Managed Resource while the Model asks for it. `Started` requests,
+* `Stopped` releases; denial parks at `denied` (actionable UI), any other
+* acquire failure parks at `idle` with the error noted — both clear
+* requirements, so a failing device never spins an acquire loop. Release
+* stops every track. No media-devices API fails the acquire instead of
+* throwing.
+*/
+const mediaStream = (config) => {
+	const request = (constraints) => {
+		if (config.request !== void 0) return config.request(constraints);
+		if (typeof navigator === "undefined" || typeof navigator.mediaDevices?.getUserMedia !== "function") return Promise.reject(/* @__PURE__ */ new Error("media devices are unavailable"));
+		return navigator.mediaDevices.getUserMedia(constraints);
+	};
+	return Bundle.make(config.name, {
+		Model: MediaStreamModel,
+		Message: MediaStreamMessage,
+		args: Schema.Struct({
+			audio: Schema.Boolean,
+			video: Schema.Boolean
+		}),
+		init: () => ({ model: {
+			status: "idle",
+			lastError: Option.none()
+		} }),
+		update: (model, message) => MediaStreamMessage.match(message, {
+			Started: () => model.status === "requesting" || model.status === "live" ? { model } : { model: {
+				...model,
+				status: "requesting"
+			} },
+			Stopped: () => ({ model: unlessSame(model, {
+				...model,
+				status: "idle"
+			}) }),
+			Live: () => ({ model: unlessSame(model, {
+				...model,
+				status: "live",
+				lastError: Option.none()
+			}) }),
+			Ended: () => ({ model: unlessSame(model, {
+				...model,
+				status: "idle"
+			}) }),
+			Denied: () => ({ model: unlessSame(model, {
+				...model,
+				status: "denied"
+			}) }),
+			Failed: ({ message }) => ({ model: unlessSame(model, {
+				...model,
+				status: "idle",
+				lastError: Option.some(message)
+			}) })
+		}),
+		resources: (args) => ManagedResource.make()((entry) => ({ stream: entry(Schema.Option(Schema.Struct({
+			audio: Schema.Boolean,
+			video: Schema.Boolean
+		})), {
+			resource: LiveStream,
+			modelToMaybeRequirements: (model) => model.status === "requesting" || model.status === "live" ? Option.some({
+				audio: args.audio,
+				video: args.video
+			}) : Option.none(),
+			acquire: (constraints) => Effect.tryPromise({
+				try: () => request(constraints),
+				catch: (error) => error
+			}),
+			onAcquired: () => MediaStreamMessage.Live(),
+			onReleased: () => MediaStreamMessage.Ended(),
+			onAcquireError: (error) => isDenied(error) ? MediaStreamMessage.Denied() : MediaStreamMessage.Failed({ message: failMessage(error) }),
+			release: (stream) => Effect.sync(() => {
+				for (const track of stream.getTracks()) track.stop();
+			})
+		}) }))
+	});
+};
+export { LiveStream, MediaStreamMessage, MediaStreamModel, mediaStream };
+
+//# sourceMappingURL=media-stream.js.map

package/dist/device/media-stream.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"media-stream.js","names":[],"sources":["../../src/device/media-stream.ts"],"sourcesContent":["import { Effect, Option, Schema } from 'effect'\nimport { defineMessageUnion } from 'foldkit/message'\nimport * as ManagedResource from 'foldkit/managedResource'\nimport type * as Update from 'foldkit/update'\nimport { Bundle } from 'foldkit-bundle'\nimport { unlessSame } from '../internal.js'\n\nexport const MediaStreamModel = Schema.Struct({\n  status: Schema.Literals(['idle', 'requesting', 'live', 'denied']),\n  lastError: Schema.OptionFromNullOr(Schema.String),\n})\nexport type MediaStreamModel = typeof MediaStreamModel.Type\n\nexport const MediaStreamMessage = defineMessageUnion({\n  Started: {},\n  Stopped: {},\n  Live: {},\n  Ended: {},\n  Denied: {},\n  Failed: { message: Schema.String },\n})\nexport type MediaStreamMessage = typeof MediaStreamMessage.Type\n\n/** A single media track: stopped on release. */\nexport interface MediaTrackHandle {\n  stop(): void\n}\n\n/** The live stream: its tracks stop on release. */\nexport interface MediaStreamHandle {\n  getTracks(): ReadonlyArray<MediaTrackHandle>\n}\n\n/** Which tracks `mediaStream` asks `getUserMedia` for. */\nexport interface MediaStreamConstraints {\n  readonly audio: boolean\n  readonly video: boolean\n}\n\n/** The live stream, for commands that attach it to an element. One assembly holds one. */\nexport const LiveStream = ManagedResource.tag<MediaStreamHandle>()('media-stream')\n\n/** The stream service a placed camera requires. */\nexport type LiveStreamService = ManagedResource.ServiceOf<typeof LiveStream>\n\ntype StreamResources = Readonly<{\n  stream: ManagedResource.Entry<\n    MediaStreamModel,\n    MediaStreamMessage,\n    Option.Option<MediaStreamConstraints>,\n    MediaStreamHandle,\n    LiveStreamService,\n    () => MediaStreamMessage\n  >\n}>\n\nconst failMessage = (error: unknown): string =>\n  error instanceof Error ? error.message : String(error)\n\nconst isDenied = (error: unknown): boolean =>\n  typeof (error as { readonly name?: unknown } | null)?.name === 'string' &&\n  ['NotAllowedError', 'SecurityError'].includes((error as { readonly name: string }).name)\n\n/**\n * A camera/mic stream as a bundle factory: one live MediaStream held in a\n * Managed Resource while the Model asks for it. `Started` requests,\n * `Stopped` releases; denial parks at `denied` (actionable UI), any other\n * acquire failure parks at `idle` with the error noted — both clear\n * requirements, so a failing device never spins an acquire loop. Release\n * stops every track. No media-devices API fails the acquire instead of\n * throwing.\n */\nexport const mediaStream = <const Name extends string>(config: {\n  readonly name: Name\n  /** Read lazily so tests can substitute a double, like the SSE bundle. */\n  readonly request?:\n    | ((constraints: MediaStreamConstraints) => Promise<MediaStreamHandle>)\n    | undefined\n}) => {\n  const request = (constraints: MediaStreamConstraints): Promise<MediaStreamHandle> => {\n    if (config.request !== undefined) return config.request(constraints)\n    if (\n      typeof navigator === 'undefined' ||\n      typeof navigator.mediaDevices?.getUserMedia !== 'function'\n    ) {\n      return Promise.reject(new Error('media devices are unavailable'))\n    }\n    return navigator.mediaDevices.getUserMedia(constraints)\n  }\n\n  return Bundle.make(config.name, {\n    Model: MediaStreamModel,\n    Message: MediaStreamMessage,\n    args: Schema.Struct({ audio: Schema.Boolean, video: Schema.Boolean }),\n    init: () => ({ model: { status: 'idle' as const, lastError: Option.none() } }),\n    update: (model, message) =>\n      MediaStreamMessage.match<\n        Update.ReturnWithOutMessage<MediaStreamModel, MediaStreamMessage, never>\n      >(message, {\n        // Starting a live stream would wait at `requesting` for an acquire\n        // that never comes: the requirements are the same.\n        Started: () =>\n          model.status === 'requesting' || model.status === 'live'\n            ? { model }\n            : { model: { ...model, status: 'requesting' as const } },\n        Stopped: () => ({ model: unlessSame(model, { ...model, status: 'idle' }) }),\n        Live: () => ({\n          model: unlessSame(model, { ...model, status: 'live', lastError: Option.none() }),\n        }),\n        // Stopping releases the stream, whose release reports it ended.\n        Ended: () => ({ model: unlessSame(model, { ...model, status: 'idle' }) }),\n        Denied: () => ({ model: unlessSame(model, { ...model, status: 'denied' }) }),\n        Failed: ({ message }) => ({\n          model: unlessSame(model, { ...model, status: 'idle', lastError: Option.some(message) }),\n        }),\n      }),\n    resources: args =>\n      ManagedResource.make<MediaStreamModel, MediaStreamMessage>()(entry => ({\n        stream: entry(\n          Schema.Option(Schema.Struct({ audio: Schema.Boolean, video: Schema.Boolean })),\n          {\n            resource: LiveStream,\n            modelToMaybeRequirements: model =>\n              model.status === 'requesting' || model.status === 'live'\n                ? Option.some({ audio: args.audio, video: args.video })\n                : Option.none(),\n            acquire: (constraints: MediaStreamConstraints) =>\n              Effect.tryPromise({\n                try: () => request(constraints),\n                catch: (error: unknown) => error,\n              }),\n            onAcquired: () => MediaStreamMessage.Live(),\n            onReleased: () => MediaStreamMessage.Ended(),\n            onAcquireError: error =>\n              isDenied(error)\n                ? MediaStreamMessage.Denied()\n                : MediaStreamMessage.Failed({ message: failMessage(error) }),\n            release: stream =>\n              Effect.sync(() => {\n                for (const track of stream.getTracks()) track.stop()\n              }),\n          },\n        ),\n      })),\n  })\n}\n"],"mappings":";;;;;;AAOA,MAAa,mBAAmB,OAAO,OAAO;CAC5C,QAAQ,OAAO,SAAS;EAAC;EAAQ;EAAc;EAAQ;CAAQ,CAAC;CAChE,WAAW,OAAO,iBAAiB,OAAO,MAAM;AAClD,CAAC;AAGD,MAAa,qBAAqB,mBAAmB;CACnD,SAAS,CAAC;CACV,SAAS,CAAC;CACV,MAAM,CAAC;CACP,OAAO,CAAC;CACR,QAAQ,CAAC;CACT,QAAQ,EAAE,SAAS,OAAO,OAAO;AACnC,CAAC;;AAoBD,MAAa,aAAa,gBAAgB,IAAuB,CAAC,CAAC,cAAc;AAgBjF,MAAM,eAAe,UACnB,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK;AAEvD,MAAM,YAAY,UAChB,OAAQ,OAA8C,SAAS,YAC/D,CAAC,mBAAmB,eAAe,CAAC,CAAC,SAAU,MAAoC,IAAI;;;;;;;;;;AAWzF,MAAa,eAA0C,WAMjD;CACJ,MAAM,WAAW,gBAAoE;EACnF,IAAI,OAAO,YAAY,KAAA,GAAW,OAAO,OAAO,QAAQ,WAAW;EACnE,IACE,OAAO,cAAc,eACrB,OAAO,UAAU,cAAc,iBAAiB,YAEhD,OAAO,QAAQ,uBAAO,IAAI,MAAM,+BAA+B,CAAC;EAElE,OAAO,UAAU,aAAa,aAAa,WAAW;CACxD;CAEA,OAAO,OAAO,KAAK,OAAO,MAAM;EAC9B,OAAO;EACP,SAAS;EACT,MAAM,OAAO,OAAO;GAAE,OAAO,OAAO;GAAS,OAAO,OAAO;EAAQ,CAAC;EACpE,aAAa,EAAE,OAAO;GAAE,QAAQ;GAAiB,WAAW,OAAO,KAAK;EAAE,EAAE;EAC5E,SAAS,OAAO,YACd,mBAAmB,MAEjB,SAAS;GAGT,eACE,MAAM,WAAW,gBAAgB,MAAM,WAAW,SAC9C,EAAE,MAAM,IACR,EAAE,OAAO;IAAE,GAAG;IAAO,QAAQ;GAAsB,EAAE;GAC3D,gBAAgB,EAAE,OAAO,WAAW,OAAO;IAAE,GAAG;IAAO,QAAQ;GAAO,CAAC,EAAE;GACzE,aAAa,EACX,OAAO,WAAW,OAAO;IAAE,GAAG;IAAO,QAAQ;IAAQ,WAAW,OAAO,KAAK;GAAE,CAAC,EACjF;GAEA,cAAc,EAAE,OAAO,WAAW,OAAO;IAAE,GAAG;IAAO,QAAQ;GAAO,CAAC,EAAE;GACvE,eAAe,EAAE,OAAO,WAAW,OAAO;IAAE,GAAG;IAAO,QAAQ;GAAS,CAAC,EAAE;GAC1E,SAAS,EAAE,eAAe,EACxB,OAAO,WAAW,OAAO;IAAE,GAAG;IAAO,QAAQ;IAAQ,WAAW,OAAO,KAAK,OAAO;GAAE,CAAC,EACxF;EACF,CAAC;EACH,YAAW,SACT,gBAAgB,KAA2C,CAAC,EAAC,WAAU,EACrE,QAAQ,MACN,OAAO,OAAO,OAAO,OAAO;GAAE,OAAO,OAAO;GAAS,OAAO,OAAO;EAAQ,CAAC,CAAC,GAC7E;GACE,UAAU;GACV,2BAA0B,UACxB,MAAM,WAAW,gBAAgB,MAAM,WAAW,SAC9C,OAAO,KAAK;IAAE,OAAO,KAAK;IAAO,OAAO,KAAK;GAAM,CAAC,IACpD,OAAO,KAAK;GAClB,UAAU,gBACR,OAAO,WAAW;IAChB,WAAW,QAAQ,WAAW;IAC9B,QAAQ,UAAmB;GAC7B,CAAC;GACH,kBAAkB,mBAAmB,KAAK;GAC1C,kBAAkB,mBAAmB,MAAM;GAC3C,iBAAgB,UACd,SAAS,KAAK,IACV,mBAAmB,OAAO,IAC1B,mBAAmB,OAAO,EAAE,SAAS,YAAY,KAAK,EAAE,CAAC;GAC/D,UAAS,WACP,OAAO,WAAW;IAChB,KAAK,MAAM,SAAS,OAAO,UAAU,GAAG,MAAM,KAAK;GACrD,CAAC;EACL,CACF,EACF,EAAE;CACN,CAAC;AACH"}

package/dist/device/permissions.d.ts

@@ -0,0 +1,106 @@
+import { Option, Queue, Schema } from "effect";
+import { Bundle } from "foldkit-bundle";
+import * as ManagedResource from "foldkit/managedResource";
+export declare const PermissionState: Schema.Literals<readonly ["granted", "denied", "prompt"]>;
+export type PermissionState = typeof PermissionState.Type;
+export declare const PermissionsModel: Schema.Struct<{
+  readonly states: Schema.$Record<Schema.String, Schema.Literals<readonly ["granted", "denied", "prompt"]>>;
+  readonly lastError: Schema.OptionFromNullOr<Schema.String>;
+}>;
+export type PermissionsModel = typeof PermissionsModel.Type;
+export declare const PermissionsMessage: import("foldkit/message").MessageUnion<{
+  readonly Snapshot: {
+    states: Schema.$Record<Schema.String, Schema.Literals<readonly ["granted", "denied", "prompt"]>>;
+  };
+  readonly Changed: {
+    name: Schema.String;
+    state: Schema.Literals<readonly ["granted", "denied", "prompt"]>;
+  };
+  readonly Cleared: {};
+  readonly Failed: {
+    message: Schema.String;
+  };
+}>;
+export type PermissionsMessage = typeof PermissionsMessage.Type;
+/** A queried permission status; `onchange` fires while watched. */
+export interface PermissionStatusHandle {
+  readonly state: string;
+  onchange: (() => void) | null;
+}
+/** The slice of the Permissions API the bundle needs. */
+export interface PermissionsHandle {
+  query(descriptor: {
+    readonly name: string;
+  }): Promise<PermissionStatusHandle>;
+}
+interface Acquired {
+  readonly statuses: ReadonlyMap<string, PermissionStatusHandle>;
+  readonly snapshot: Readonly<Record<string, PermissionState>>;
+  readonly events: Queue.Queue<PermissionsMessage>;
+}
+/** The watched statuses, for the changes subscription. One assembly holds one. */
+export declare const Watch: ManagedResource.ManagedResource<Acquired, ManagedResource.ManagedResourceService<"permissions">>;
+/** The watch service a placed Permissions bundle requires. */
+export type WatchService = ManagedResource.ServiceOf<typeof Watch>;
+/**
+ * Permission states as a bundle factory: queried on placement, kept current
+ * by each status object's `onchange`. A resource holds the status objects
+ * (they cannot live in the Model); its queue feeds the subscription, and
+ * release detaches every handler. An unknown permission name fails the
+ * acquire; an unknown state string fails it too — both become `Failed`,
+ * never Model facts.
+ */
+export declare const permissions: <const Name extends string>(config: {
+  readonly name: Name;
+  /** Read lazily so tests can substitute a double, like the SSE bundle. */
+  readonly create?: ((navigator: Navigator) => PermissionsHandle | null) | undefined;
+}) => Bundle.Bundle<Name, {
+  readonly names: readonly string[];
+}, {
+  readonly states: {
+    readonly [x: string]: "denied" | "granted" | "prompt";
+  };
+  readonly lastError: Option.Option<string>;
+}, {
+  readonly _tag: "Changed";
+  readonly name: string;
+  readonly state: "denied" | "granted" | "prompt";
+} | {
+  readonly _tag: "Cleared";
+} | {
+  readonly _tag: "Failed";
+  readonly message: string;
+} | {
+  readonly _tag: "Snapshot";
+  readonly states: {
+    readonly [x: string]: "denied" | "granted" | "prompt";
+  };
+}, never, never, ManagedResource.ManagedResourceService<"permissions">, void, {
+  watch: ManagedResource.Entry<{
+    readonly states: {
+      readonly [x: string]: "denied" | "granted" | "prompt";
+    };
+    readonly lastError: Option.Option<string>;
+  }, {
+    readonly _tag: "Changed";
+    readonly name: string;
+    readonly state: "denied" | "granted" | "prompt";
+  } | {
+    readonly _tag: "Cleared";
+  } | {
+    readonly _tag: "Failed";
+    readonly message: string;
+  } | {
+    readonly _tag: "Snapshot";
+    readonly states: {
+      readonly [x: string]: "denied" | "granted" | "prompt";
+    };
+  }, Option.Option<readonly string[]>, Acquired, ManagedResource.ManagedResourceService<"permissions">, ({ snapshot }: Acquired) => {
+    readonly _tag: "Snapshot";
+    readonly states: {
+      readonly [x: string]: "denied" | "granted" | "prompt";
+    };
+  }>;
+}, {}>;
+export {};
+//# sourceMappingURL=permissions.d.ts.map

package/dist/device/permissions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"permissions.d.ts","names":[],"sources":["../../src/device/permissions.ts"],"mappings":";;;qBAQa,iBAAe,OAAA;YAChB,yBAAyB,gBAAgB;qBAExC,kBAAgB,OAAA;;;;YAIjB,0BAA0B,iBAAiB;qBAE1C,8CAAkB;;IACjB,QAAM,OAAA,QAAA,OAAA,QAAA,OAAA;;;IACP,MAAI,OAAA;IAAiB,OAAK,OAAA;;;;IAE3B,SAAO,OAAA;;;YAEP,4BAA4B,mBAAmB;;iBAG1C;WACN;EACT;;;iBAIe;EACf,MAAM;aAAuB;MAAiB,QAAQ;;UAG9C;WACC,UAAU,oBAAoB;WAC9B,UAAU,SAAS,eAAe;WAClC,QAAQ,MAAM,MAAM;;;qBAIlB,OAAK,gBAAA,gBAAA,UAAA,gBAAA;;YAGN,eAAe,gBAAgB,iBAAiB;;;;;;;;;qBAoB/C,oBAAqB,qBAAmB;WAC1C,MAAM;;WAEN,WAAW,WAAW,cAAc;MAC9C,OAAA,OAAA"}

package/dist/device/permissions.js

@@ -0,0 +1,143 @@
+import { Effect, Option, Queue, Schema, Stream } from "effect";
+import { defineMessageUnion } from "foldkit/message";
+import * as Subscription from "foldkit/subscription";
+import { Bundle } from "foldkit-bundle";
+import { unlessSame } from "../internal.js";
+import * as ManagedResource from "foldkit/managedResource";
+// src/device/permissions.ts
+const PermissionState = Schema.Literals([
+	"granted",
+	"denied",
+	"prompt"
+]);
+const PermissionsModel = Schema.Struct({
+	states: Schema.Record(Schema.String, PermissionState),
+	lastError: Schema.OptionFromNullOr(Schema.String)
+});
+const PermissionsMessage = defineMessageUnion({
+	Snapshot: { states: Schema.Record(Schema.String, PermissionState) },
+	Changed: {
+		name: Schema.String,
+		state: PermissionState
+	},
+	Cleared: {},
+	Failed: { message: Schema.String }
+});
+/** The watched statuses, for the changes subscription. One assembly holds one. */
+const Watch = ManagedResource.tag()("permissions");
+const failMessage = (error) => error instanceof Error ? error.message : String(error);
+const readState = (state, name) => {
+	if (state !== "granted" && state !== "denied" && state !== "prompt") throw new Error(`unknown permission state for ${name}: ${state}`);
+	return state;
+};
+/**
+* Permission states as a bundle factory: queried on placement, kept current
+* by each status object's `onchange`. A resource holds the status objects
+* (they cannot live in the Model); its queue feeds the subscription, and
+* release detaches every handler. An unknown permission name fails the
+* acquire; an unknown state string fails it too — both become `Failed`,
+* never Model facts.
+*/
+const permissions = (config) => {
+	const handle = () => {
+		if (typeof navigator === "undefined") return null;
+		if (config.create !== void 0) return config.create(navigator);
+		return navigator.permissions ?? null;
+	};
+	return Bundle.make(config.name, {
+		Model: PermissionsModel,
+		Message: PermissionsMessage,
+		args: Schema.Struct({ names: Schema.Array(Schema.String) }),
+		init: () => ({ model: {
+			states: {},
+			lastError: Option.none()
+		} }),
+		update: (model, message) => PermissionsMessage.match(message, {
+			Snapshot: ({ states }) => {
+				const next = unlessSame(model.states, { ...states });
+				return next === model.states ? { model } : { model: {
+					...model,
+					states: next
+				} };
+			},
+			Changed: ({ name, state }) => Object.hasOwn(model.states, name) && model.states[name] === state ? { model } : { model: {
+				...model,
+				states: {
+					...model.states,
+					[name]: state
+				}
+			} },
+			Cleared: () => Object.keys(model.states).length === 0 ? { model } : { model: {
+				...model,
+				states: {}
+			} },
+			Failed: ({ message }) => ({ model: unlessSame(model, {
+				...model,
+				lastError: Option.some(message)
+			}) })
+		}),
+		resources: (args) => {
+			const names = Option.some([...new Set(args.names)]);
+			return ManagedResource.make()((entry) => ({ watch: entry(Schema.Option(Schema.Array(Schema.String)), {
+				resource: Watch,
+				modelToMaybeRequirements: () => names,
+				acquire: (names) => Effect.gen(function* () {
+					const api = handle();
+					if (api === null) throw new Error("permissions are unavailable");
+					const events = yield* Queue.unbounded();
+					const statuses = /* @__PURE__ */ new Map();
+					let tail = Promise.resolve();
+					const offer = (message) => {
+						const run = () => Effect.runPromise(Queue.offer(events, message)).then(() => void 0, () => void 0);
+						tail = tail.then(run, run);
+					};
+					const queried = [];
+					for (const name of names) {
+						const status = yield* Effect.tryPromise({
+							try: () => api.query({ name }),
+							catch: (error) => error
+						});
+						queried.push([
+							name,
+							status,
+							readState(status.state, name)
+						]);
+					}
+					const snapshot = {};
+					for (const [name, status, state] of queried) {
+						status.onchange = () => {
+							try {
+								offer(PermissionsMessage.Changed({
+									name,
+									state: readState(status.state, name)
+								}));
+							} catch {
+								offer(PermissionsMessage.Failed({ message: `unknown permission state for ${name}` }));
+							}
+						};
+						statuses.set(name, status);
+						snapshot[name] = state;
+					}
+					return {
+						statuses,
+						snapshot,
+						events
+					};
+				}),
+				onAcquired: ({ snapshot }) => PermissionsMessage.Snapshot({ states: { ...snapshot } }),
+				onReleased: () => PermissionsMessage.Cleared(),
+				onAcquireError: (error) => PermissionsMessage.Failed({ message: failMessage(error) }),
+				release: ({ statuses, events }) => Effect.asVoid(Effect.andThen(Effect.sync(() => {
+					for (const status of statuses.values()) status.onchange = null;
+				}), Queue.shutdown(events)))
+			}) }));
+		},
+		subscriptions: () => Subscription.make()(() => ({ changes: Subscription.persistentEntry(Stream.unwrap(Effect.matchEffect(Watch.get, {
+			onFailure: () => Effect.succeed(Stream.empty),
+			onSuccess: ({ events }) => Effect.succeed(Stream.fromQueue(events))
+		}))) }))
+	});
+};
+export { PermissionState, PermissionsMessage, PermissionsModel, Watch, permissions };
+
+//# sourceMappingURL=permissions.js.map

package/dist/device/permissions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"permissions.js","names":[],"sources":["../../src/device/permissions.ts"],"sourcesContent":["import { Effect, Option, Queue, Schema, Stream } from 'effect'\nimport { defineMessageUnion } from 'foldkit/message'\nimport * as ManagedResource from 'foldkit/managedResource'\nimport * as Subscription from 'foldkit/subscription'\nimport type * as Update from 'foldkit/update'\nimport { Bundle } from 'foldkit-bundle'\nimport { unlessSame } from '../internal.js'\n\nexport const PermissionState = Schema.Literals(['granted', 'denied', 'prompt'])\nexport type PermissionState = typeof PermissionState.Type\n\nexport const PermissionsModel = Schema.Struct({\n  states: Schema.Record(Schema.String, PermissionState),\n  lastError: Schema.OptionFromNullOr(Schema.String),\n})\nexport type PermissionsModel = typeof PermissionsModel.Type\n\nexport const PermissionsMessage = defineMessageUnion({\n  Snapshot: { states: Schema.Record(Schema.String, PermissionState) },\n  Changed: { name: Schema.String, state: PermissionState },\n  Cleared: {},\n  Failed: { message: Schema.String },\n})\nexport type PermissionsMessage = typeof PermissionsMessage.Type\n\n/** A queried permission status; `onchange` fires while watched. */\nexport interface PermissionStatusHandle {\n  readonly state: string\n  onchange: (() => void) | null\n}\n\n/** The slice of the Permissions API the bundle needs. */\nexport interface PermissionsHandle {\n  query(descriptor: { readonly name: string }): Promise<PermissionStatusHandle>\n}\n\ninterface Acquired {\n  readonly statuses: ReadonlyMap<string, PermissionStatusHandle>\n  readonly snapshot: Readonly<Record<string, PermissionState>>\n  readonly events: Queue.Queue<PermissionsMessage>\n}\n\n/** The watched statuses, for the changes subscription. One assembly holds one. */\nexport const Watch = ManagedResource.tag<Acquired>()('permissions')\n\n/** The watch service a placed Permissions bundle requires. */\nexport type WatchService = ManagedResource.ServiceOf<typeof Watch>\n\nconst failMessage = (error: unknown): string =>\n  error instanceof Error ? error.message : String(error)\n\nconst readState = (state: string, name: string): PermissionState => {\n  if (state !== 'granted' && state !== 'denied' && state !== 'prompt') {\n    throw new Error(`unknown permission state for ${name}: ${state}`)\n  }\n  return state\n}\n\n/**\n * Permission states as a bundle factory: queried on placement, kept current\n * by each status object's `onchange`. A resource holds the status objects\n * (they cannot live in the Model); its queue feeds the subscription, and\n * release detaches every handler. An unknown permission name fails the\n * acquire; an unknown state string fails it too — both become `Failed`,\n * never Model facts.\n */\nexport const permissions = <const Name extends string>(config: {\n  readonly name: Name\n  /** Read lazily so tests can substitute a double, like the SSE bundle. */\n  readonly create?: ((navigator: Navigator) => PermissionsHandle | null) | undefined\n}) => {\n  const handle = (): PermissionsHandle | null => {\n    if (typeof navigator === 'undefined') return null\n    if (config.create !== undefined) return config.create(navigator)\n    const api = navigator.permissions as unknown as PermissionsHandle | undefined\n    return api ?? null\n  }\n\n  return Bundle.make(config.name, {\n    Model: PermissionsModel,\n    Message: PermissionsMessage,\n    args: Schema.Struct({ names: Schema.Array(Schema.String) }),\n    init: () => ({ model: { states: {}, lastError: Option.none() } }),\n    update: (model, message) =>\n      PermissionsMessage.match<\n        Update.ReturnWithOutMessage<PermissionsModel, PermissionsMessage, never>\n      >(message, {\n        Snapshot: ({ states }) => {\n          const next = unlessSame(model.states, { ...states })\n          return next === model.states ? { model } : { model: { ...model, states: next } }\n        },\n        Changed: ({ name, state }) =>\n          Object.hasOwn(model.states, name) && model.states[name] === state\n            ? { model }\n            : { model: { ...model, states: { ...model.states, [name]: state } } },\n        Cleared: () =>\n          Object.keys(model.states).length === 0 ? { model } : { model: { ...model, states: {} } },\n        Failed: ({ message }) => ({\n          model: unlessSame(model, { ...model, lastError: Option.some(message) }),\n        }),\n      }),\n    resources: args => {\n      const names = Option.some([...new Set(args.names)])\n      return ManagedResource.make<PermissionsModel, PermissionsMessage>()(entry => ({\n        watch: entry(Schema.Option(Schema.Array(Schema.String)), {\n          resource: Watch,\n          modelToMaybeRequirements: () => names,\n          acquire: (names: ReadonlyArray<string>) =>\n            Effect.gen(function* () {\n              const api = handle()\n              if (api === null) throw new Error('permissions are unavailable')\n              const events = yield* Queue.unbounded<PermissionsMessage>()\n              const statuses = new Map<string, PermissionStatusHandle>()\n              // Offers run in arrival order; see the WebSocket bundle.\n              let tail: Promise<void> = Promise.resolve()\n              const offer = (message: PermissionsMessage) => {\n                const run = () =>\n                  Effect.runPromise(Queue.offer(events, message)).then(\n                    () => undefined,\n                    () => undefined,\n                  )\n                tail = tail.then(run, run)\n              }\n              // Two phases: query and validate everything first, so a later\n              // name failing cannot abandon handlers attached to earlier ones.\n              const queried: Array<readonly [string, PermissionStatusHandle, PermissionState]> = []\n              for (const name of names) {\n                const status = yield* Effect.tryPromise({\n                  try: () => api.query({ name }),\n                  catch: (error: unknown) => error,\n                })\n                queried.push([name, status, readState(status.state, name)] as const)\n              }\n              const snapshot: Record<string, PermissionState> = {}\n              for (const [name, status, state] of queried) {\n                status.onchange = () => {\n                  try {\n                    offer(\n                      PermissionsMessage.Changed({ name, state: readState(status.state, name) }),\n                    )\n                  } catch {\n                    // readState evaluates before offer runs, so a state the\n                    // schema rejects lands here instead of crashing the handler.\n                    offer(\n                      PermissionsMessage.Failed({\n                        message: `unknown permission state for ${name}`,\n                      }),\n                    )\n                  }\n                }\n                statuses.set(name, status)\n                snapshot[name] = state\n              }\n              return { statuses, snapshot, events }\n            }),\n          // The snapshot is captured during acquire, so onAcquired cannot\n          // throw re-reading a state that changed mid-acquire.\n          onAcquired: ({ snapshot }) => PermissionsMessage.Snapshot({ states: { ...snapshot } }),\n          onReleased: () => PermissionsMessage.Cleared(),\n          onAcquireError: error => PermissionsMessage.Failed({ message: failMessage(error) }),\n          release: ({ statuses, events }) =>\n            Effect.asVoid(\n              Effect.andThen(\n                Effect.sync(() => {\n                  for (const status of statuses.values()) status.onchange = null\n                }),\n                Queue.shutdown(events),\n              ),\n            ),\n        }),\n      }))\n    },\n    subscriptions: (): Subscription.Subscriptions<\n      PermissionsModel,\n      PermissionsMessage,\n      WatchService\n    > =>\n      Subscription.make<PermissionsModel, PermissionsMessage, WatchService>()(() => ({\n        // No model gate: the queue outlives every state change, and release\n        // ends the stream through teardown, not through dependencies.\n        changes: Subscription.persistentEntry(\n          Stream.unwrap(\n            Effect.matchEffect(Watch.get, {\n              // Released between placement and attach: end quietly.\n              onFailure: () => Effect.succeed(Stream.empty),\n              onSuccess: ({ events }) => Effect.succeed(Stream.fromQueue(events)),\n            }),\n          ),\n        ),\n      })),\n  })\n}\n"],"mappings":"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"}

package/dist/dom/autofocus.d.ts

@@ -0,0 +1,15 @@
+import { Schema } from "effect";
+import * as Mount from "foldkit/mount";
+export declare const Focused: Schema.TaggedStruct<"Focused", {}>;
+export type Focused = typeof Focused.Type;
+/**
+ * Autofocus as a Mount: focuses the element on insert, then emits `Focused`.
+ * The message means focus was requested — a non-focusable element or a
+ * hidden tab may decline, and the browser does not report that. Plain
+ * `focus()`, no scroll options: scroll behavior stays the application's
+ * choice.
+ */
+export declare const Autofocus: Mount.MountDefinitionNoArgs<"Autofocus", {
+  readonly _tag: "Focused";
+}>;
+//# sourceMappingURL=autofocus.d.ts.map

package/dist/dom/autofocus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"autofocus.d.ts","names":[],"sources":["../../src/dom/autofocus.ts"],"mappings":";;qBAGa,SAAO,OAAA;YACR,iBAAiB,QAAQ;;;;;;;;qBASxB,WAAS,MAAA"}

package/dist/dom/autofocus.js

@@ -0,0 +1,22 @@
+import { Effect, Schema } from "effect";
+import * as Mount from "foldkit/mount";
+// src/dom/autofocus.ts
+const Focused = Schema.TaggedStruct("Focused", {});
+/**
+* Autofocus as a Mount: focuses the element on insert, then emits `Focused`.
+* The message means focus was requested — a non-focusable element or a
+* hidden tab may decline, and the browser does not report that. Plain
+* `focus()`, no scroll options: scroll behavior stays the application's
+* choice.
+*/
+const Autofocus = Mount.define("Autofocus", {
+	messages: [Focused],
+	execute: ({ element }) => Effect.sync(() => {
+		const focusable = element;
+		if (typeof focusable.focus === "function") focusable.focus.call(element);
+		return Focused.make({});
+	})
+});
+export { Autofocus, Focused };
+
+//# sourceMappingURL=autofocus.js.map

package/dist/dom/autofocus.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"autofocus.js","names":[],"sources":["../../src/dom/autofocus.ts"],"sourcesContent":["import { Effect, Schema } from 'effect'\nimport * as Mount from 'foldkit/mount'\n\nexport const Focused = Schema.TaggedStruct('Focused', {})\nexport type Focused = typeof Focused.Type\n\n/**\n * Autofocus as a Mount: focuses the element on insert, then emits `Focused`.\n * The message means focus was requested — a non-focusable element or a\n * hidden tab may decline, and the browser does not report that. Plain\n * `focus()`, no scroll options: scroll behavior stays the application's\n * choice.\n */\nexport const Autofocus = Mount.define('Autofocus', {\n  messages: [Focused],\n  execute: ({ element }) =>\n    Effect.sync(() => {\n      const focusable = element as unknown as { readonly focus?: unknown }\n      if (typeof focusable.focus === 'function') {\n        ;(focusable.focus as () => void).call(element)\n      }\n      return Focused.make({})\n    }),\n})\n"],"mappings":";;;AAGA,MAAa,UAAU,OAAO,aAAa,WAAW,CAAC,CAAC;;;;;;;;AAUxD,MAAa,YAAY,MAAM,OAAO,aAAa;CACjD,UAAU,CAAC,OAAO;CAClB,UAAU,EAAE,cACV,OAAO,WAAW;EAChB,MAAM,YAAY;EAClB,IAAI,OAAO,UAAU,UAAU,YAC5B,UAAW,MAAqB,KAAK,OAAO;EAE/C,OAAO,QAAQ,KAAK,CAAC,CAAC;CACxB,CAAC;AACL,CAAC"}

package/dist/dom/clipboard.d.ts

@@ -0,0 +1,30 @@
+import { Schema } from "effect";
+import { Command } from "foldkit/command";
+export declare const ClipboardMessage: import("foldkit/message").MessageUnion<{
+  readonly Copied: {};
+  readonly CopyFailed: {
+    message: Schema.String;
+  };
+}>;
+export type ClipboardMessage = typeof ClipboardMessage.Type;
+export declare const ClipboardReadMessage: import("foldkit/message").MessageUnion<{
+  readonly Read: {
+    text: Schema.String;
+  };
+  readonly ReadFailed: {
+    message: Schema.String;
+  };
+}>;
+export type ClipboardReadMessage = typeof ClipboardReadMessage.Type;
+/**
+ * Copies text to the clipboard. Without a clipboard API (SSR, insecure
+ * context, denied permission) the command yields `CopyFailed` instead of
+ * throwing, so `update` handles both outcomes as Messages.
+ */
+export declare const copyText: (text: string) => Command<ClipboardMessage, never, never>;
+/**
+ * Reads the clipboard's text. The browser may ask the user first; a refusal,
+ * an insecure context or no clipboard API yields `ReadFailed`.
+ */
+export declare const readText: () => Command<ClipboardReadMessage, never, never>;
+//# sourceMappingURL=clipboard.d.ts.map

package/dist/dom/clipboard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clipboard.d.ts","names":[],"sources":["../../src/dom/clipboard.ts"],"mappings":";;qBASa,4CAAgB;;;IAEb,SAAO,OAAA;;;YAEX,0BAA0B,iBAAiB;qBAE1C,gDAAoB;;IACvB,MAAI,OAAA;;;IACE,SAAO,OAAA;;;YAEX,8BAA8B,qBAAqB;;;;;;qBAUlD,WAAQ,iBAAmB,QAAQ;;;;;qBAsBnC,gBAAe,QAAQ"}

package/dist/dom/clipboard.js

@@ -0,0 +1,50 @@
+import { Effect, Schema } from "effect";
+import { defineMessageUnion } from "foldkit/message";
+// src/dom/clipboard.ts
+/**
+* The clipboard as Commands: run in `update` beside any bundle. A copy yields
+* `Copied` or `CopyFailed`, a read `Read` or `ReadFailed`. No Model involved:
+* the clipboard is not application state.
+*/
+const ClipboardMessage = defineMessageUnion({
+	Copied: {},
+	CopyFailed: { message: Schema.String }
+});
+const ClipboardReadMessage = defineMessageUnion({
+	Read: { text: Schema.String },
+	ReadFailed: { message: Schema.String }
+});
+const failMessage = (error) => error instanceof Error ? error.message : String(error);
+/**
+* Copies text to the clipboard. Without a clipboard API (SSR, insecure
+* context, denied permission) the command yields `CopyFailed` instead of
+* throwing, so `update` handles both outcomes as Messages.
+*/
+const copyText = (text) => ({
+	name: "Clipboard.copy",
+	args: { text },
+	effect: typeof navigator !== "undefined" && typeof navigator.clipboard?.writeText === "function" ? Effect.matchEffect(Effect.tryPromise({
+		try: () => navigator.clipboard.writeText(text),
+		catch: failMessage
+	}), {
+		onFailure: (message) => Effect.succeed(ClipboardMessage.CopyFailed({ message })),
+		onSuccess: () => Effect.succeed(ClipboardMessage.Copied())
+	}) : Effect.succeed(ClipboardMessage.CopyFailed({ message: "clipboard is unavailable" }))
+});
+/**
+* Reads the clipboard's text. The browser may ask the user first; a refusal,
+* an insecure context or no clipboard API yields `ReadFailed`.
+*/
+const readText = () => ({
+	name: "Clipboard.read",
+	effect: typeof navigator !== "undefined" && typeof navigator.clipboard?.readText === "function" ? Effect.matchEffect(Effect.tryPromise({
+		try: () => navigator.clipboard.readText(),
+		catch: failMessage
+	}), {
+		onFailure: (message) => Effect.succeed(ClipboardReadMessage.ReadFailed({ message })),
+		onSuccess: (text) => Effect.succeed(ClipboardReadMessage.Read({ text }))
+	}) : Effect.succeed(ClipboardReadMessage.ReadFailed({ message: "clipboard is unavailable" }))
+});
+export { ClipboardMessage, ClipboardReadMessage, copyText, readText };
+
+//# sourceMappingURL=clipboard.js.map

package/dist/dom/clipboard.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"clipboard.js","names":[],"sources":["../../src/dom/clipboard.ts"],"sourcesContent":["/**\n * The clipboard as Commands: run in `update` beside any bundle. A copy yields\n * `Copied` or `CopyFailed`, a read `Read` or `ReadFailed`. No Model involved:\n * the clipboard is not application state.\n */\nimport { Effect, Schema } from 'effect'\nimport type { Command } from 'foldkit/command'\nimport { defineMessageUnion } from 'foldkit/message'\n\nexport const ClipboardMessage = defineMessageUnion({\n  Copied: {},\n  CopyFailed: { message: Schema.String },\n})\nexport type ClipboardMessage = typeof ClipboardMessage.Type\n\nexport const ClipboardReadMessage = defineMessageUnion({\n  Read: { text: Schema.String },\n  ReadFailed: { message: Schema.String },\n})\nexport type ClipboardReadMessage = typeof ClipboardReadMessage.Type\n\nconst failMessage = (error: unknown): string =>\n  error instanceof Error ? error.message : String(error)\n\n/**\n * Copies text to the clipboard. Without a clipboard API (SSR, insecure\n * context, denied permission) the command yields `CopyFailed` instead of\n * throwing, so `update` handles both outcomes as Messages.\n */\nexport const copyText = (text: string): Command<ClipboardMessage, never, never> => ({\n  name: 'Clipboard.copy',\n  args: { text },\n  effect:\n    typeof navigator !== 'undefined' && typeof navigator.clipboard?.writeText === 'function'\n      ? Effect.matchEffect(\n          Effect.tryPromise({\n            try: () => navigator.clipboard.writeText(text),\n            catch: failMessage,\n          }),\n          {\n            onFailure: message => Effect.succeed(ClipboardMessage.CopyFailed({ message })),\n            onSuccess: () => Effect.succeed(ClipboardMessage.Copied()),\n          },\n        )\n      : Effect.succeed(ClipboardMessage.CopyFailed({ message: 'clipboard is unavailable' })),\n})\n\n/**\n * Reads the clipboard's text. The browser may ask the user first; a refusal,\n * an insecure context or no clipboard API yields `ReadFailed`.\n */\nexport const readText = (): Command<ClipboardReadMessage, never, never> => ({\n  name: 'Clipboard.read',\n  effect:\n    typeof navigator !== 'undefined' && typeof navigator.clipboard?.readText === 'function'\n      ? Effect.matchEffect(\n          Effect.tryPromise({ try: () => navigator.clipboard.readText(), catch: failMessage }),\n          {\n            onFailure: message => Effect.succeed(ClipboardReadMessage.ReadFailed({ message })),\n            onSuccess: text => Effect.succeed(ClipboardReadMessage.Read({ text })),\n          },\n        )\n      : Effect.succeed(ClipboardReadMessage.ReadFailed({ message: 'clipboard is unavailable' })),\n})\n"],"mappings":";;;;;;;;AASA,MAAa,mBAAmB,mBAAmB;CACjD,QAAQ,CAAC;CACT,YAAY,EAAE,SAAS,OAAO,OAAO;AACvC,CAAC;AAGD,MAAa,uBAAuB,mBAAmB;CACrD,MAAM,EAAE,MAAM,OAAO,OAAO;CAC5B,YAAY,EAAE,SAAS,OAAO,OAAO;AACvC,CAAC;AAGD,MAAM,eAAe,UACnB,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK;;;;;;AAOvD,MAAa,YAAY,UAA2D;CAClF,MAAM;CACN,MAAM,EAAE,KAAK;CACb,QACE,OAAO,cAAc,eAAe,OAAO,UAAU,WAAW,cAAc,aAC1E,OAAO,YACL,OAAO,WAAW;EAChB,WAAW,UAAU,UAAU,UAAU,IAAI;EAC7C,OAAO;CACT,CAAC,GACD;EACE,YAAW,YAAW,OAAO,QAAQ,iBAAiB,WAAW,EAAE,QAAQ,CAAC,CAAC;EAC7E,iBAAiB,OAAO,QAAQ,iBAAiB,OAAO,CAAC;CAC3D,CACF,IACA,OAAO,QAAQ,iBAAiB,WAAW,EAAE,SAAS,2BAA2B,CAAC,CAAC;AAC3F;;;;;AAMA,MAAa,kBAA+D;CAC1E,MAAM;CACN,QACE,OAAO,cAAc,eAAe,OAAO,UAAU,WAAW,aAAa,aACzE,OAAO,YACL,OAAO,WAAW;EAAE,WAAW,UAAU,UAAU,SAAS;EAAG,OAAO;CAAY,CAAC,GACnF;EACE,YAAW,YAAW,OAAO,QAAQ,qBAAqB,WAAW,EAAE,QAAQ,CAAC,CAAC;EACjF,YAAW,SAAQ,OAAO,QAAQ,qBAAqB,KAAK,EAAE,KAAK,CAAC,CAAC;CACvE,CACF,IACA,OAAO,QAAQ,qBAAqB,WAAW,EAAE,SAAS,2BAA2B,CAAC,CAAC;AAC/F"}

package/dist/dom/editable-text.d.ts

@@ -0,0 +1,72 @@
+import { Schema } from "effect";
+import * as Mount from "foldkit/mount";
+export declare const TextEdited: Schema.TaggedStruct<"TextEdited", {
+  /** The field, by its marking attribute's value. */
+  readonly field: Schema.String;
+  readonly text: Schema.String;
+}>;
+export type TextEdited = typeof TextEdited.Type;
+export declare const TextCommitted: Schema.TaggedStruct<"TextCommitted", {
+  readonly field: Schema.String;
+  readonly text: Schema.String;
+}>;
+export type TextCommitted = typeof TextCommitted.Type;
+export declare const TextCancelled: Schema.TaggedStruct<"TextCancelled", {
+  readonly field: Schema.String;
+  /** The text the field had when editing began, which the DOM shows again. */
+  readonly initial: Schema.String;
+}>;
+export type TextCancelled = typeof TextCancelled.Type;
+export declare const EditAsked: Schema.TaggedStruct<"EditAsked", {
+  /** A marked field, not editable yet, that was double-clicked. */
+  readonly field: Schema.String;
+}>;
+export type EditAsked = typeof EditAsked.Type;
+export type TextFact = TextEdited | TextCommitted | TextCancelled | EditAsked;
+/**
+ * A field's text. A browser ends an edited element with a line break it adds
+ * itself, which is not the author's; in one line, the author's breaks are spaces.
+ */
+export declare const textOf: (element: HTMLElement) => string;
+/**
+ * Text typed into an editable descendant of an element, as a Mount: one set of
+ * listeners on the container, like `Targets`. A field is a descendant marked
+ * by an attribute whose value names it, while it is `contenteditable`. The
+ * view decides which one is; the Mount focuses it as it becomes so (made
+ * editable, or drawn editable), with the caret at its end, and at no other
+ * time. When Enter or Escape ends an edit and the view then removes the field
+ * or makes it no longer editable, focus, left on nothing, comes back to the
+ * container, so the next key reaches it; give the container a `tabindex`. A double-click on a marked field that is not editable yet asks for it
+ * to be (`EditAsked`).
+ *
+ * It reads `innerText`, never `innerHTML`, so what arrives is text. A field is
+ * one line unless it carries `aria-multiline="true"`: in one line, a line
+ * break becomes a space. Nothing is reported while an input method composes;
+ * the composed text arrives once, when it is done.
+ *
+ * Enter commits (Shift+Enter breaks a line in a multiline field), and so does
+ * leaving the field. Escape cancels, and puts the text the field had when
+ * editing began back in the DOM, since a view that stopped redrawing the field
+ * while it was edited will not. Where the browser lacks `plaintext-only`, a
+ * paste is inserted as text. What an edit means is the parent's `update`.
+ */
+export declare const EditableText: Mount.MountDefinitionWithArgs<"EditableText", {
+  /** The attribute that marks a field, holding its name. */
+  attribute: Schema.String;
+}, {
+  readonly _tag: "TextEdited";
+  readonly field: string;
+  readonly text: string;
+} | {
+  readonly _tag: "TextCommitted";
+  readonly field: string;
+  readonly text: string;
+} | {
+  readonly _tag: "TextCancelled";
+  readonly field: string;
+  readonly initial: string;
+} | {
+  readonly _tag: "EditAsked";
+  readonly field: string;
+}>;
+//# sourceMappingURL=editable-text.d.ts.map

package/dist/dom/editable-text.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"editable-text.d.ts","names":[],"sources":["../../src/dom/editable-text.ts"],"mappings":";;qBAGa,YAAU,OAAA;;;;;YAKX,oBAAoB,WAAW;qBAE9B,eAAa,OAAA;;;;YAId,uBAAuB,cAAc;qBAEpC,eAAa,OAAA;;;;;YAKd,uBAAuB,cAAc;qBAEpC,WAAS,OAAA;;;;YAIV,mBAAmB,UAAU;YAE7B,WAAW,aAAa,gBAAgB,gBAAgB;;;;;qBASvD,SAAM,SAAa;;;;;;;;;;;;;;;;;;;;;;;qBA0CnB,cAAY,MAAA"}