@jigs.design/runtime 0.0.0-stage → 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Tom Bates
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,30 @@
-# Temporary Holding Version
+# @jigs.design/runtime
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+The layer the server and the browser share: the program format, the types on the wire, the sandboxed runtime, and the tree store. It imports neither the compiler nor the prompt.
+
+`@jigs.design/server`, `@jigs.design/client` and `@jigs.design/react` re-export the shared types, so most code imports them from one of those.
+
+## Entry points
+
+| Entry                        | What it holds                                                                                                                                                                                                                                                                   |
+| ---------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `@jigs.design/runtime`       | `Program`, `SessionEvent`, `Message`, `Diagnostic` and the other shared types; the frame protocol (`HostMessage`, `FrameMessage`, `Op`); the JSON checks the browser runs; `createTreeStore` with its caps `MAX_NODES`, `MAX_OPS` and `MAX_TEXT`; the image and link allowlists |
+| `@jigs.design/runtime/frame` | The sandbox frame document, its content security policy, the worker runtime, and `WATCHDOG_MS` and `HEARTBEAT_MS`. The server serves it                                                                                                                                         |
+
+## How a program runs
+
+The server serves the frame document from its route. The frame starts a worker and runs the compiled program there, with a watchdog that kills a program that stops answering. The worker sends tree ops to the page, where the tree store applies them, within the same caps on nodes, ops and text the worker keeps, and the view draws the tree. Functions never leave the worker; they cross as ids. The browser checks every value from the server with `parse.ts`, since it imports no schema library.
+
+## Source
+
+- `src/types.ts`: the shared types and `PROGRAM_FORMAT`.
+- `src/protocol.ts`: messages between the page, the frame and the worker.
+- `src/parse.ts`: checks for JSON arriving in the browser.
+- `src/frame.ts`, `src/frame-policy.ts`: the frame document and its policy.
+- `src/runtime-core.ts`: the runtime inside the worker.
+- `src/tree-store.ts`: the tree the view draws.
+- `src/urls.ts`, `src/validate.ts`: allowed images and links, and prop checks.
+
+## Docs
+
+[Sandbox](../../apps/docs/docs/react/sandbox.mdx), [Frame protocol](../../apps/docs/docs/renderers/protocol.mdx) and [Packages](../../apps/docs/docs/packages/index.mdx).

package/dist/frame-policy.d.ts

@@ -0,0 +1,11 @@
+//#region src/frame-policy.d.ts
+/**
+ * The sandbox frame's content security policy, without `frame-ancestors`.
+ * The `sandbox` directive keeps the document's origin opaque even when a page
+ * frames it without the attribute, and `default-src 'none'` covers every
+ * fetch directive not listed, so nothing in the frame can make a request.
+ * The frame checks that this policy is the one in force before it runs
+ * anything, and the view looks for it when the frame does not start.
+ */
+export declare const frameSecurityPolicy: string;
+//#endregion

package/dist/frame-policy.js

@@ -0,0 +1,17 @@
+//#region src/frame-policy.ts
+/**
+* The sandbox frame's content security policy, without `frame-ancestors`.
+* The `sandbox` directive keeps the document's origin opaque even when a page
+* frames it without the attribute, and `default-src 'none'` covers every
+* fetch directive not listed, so nothing in the frame can make a request.
+* The frame checks that this policy is the one in force before it runs
+* anything, and the view looks for it when the frame does not start.
+*/
+const frameSecurityPolicy = [
+	"sandbox allow-scripts",
+	"default-src 'none'",
+	"script-src 'unsafe-inline' 'unsafe-eval'",
+	"worker-src blob:"
+].join("; ");
+//#endregion
+export { frameSecurityPolicy };

package/dist/frame.d.ts

@@ -0,0 +1,42 @@
+import { frameSecurityPolicy } from "./frame-policy.js";
+import { createRuntime } from "./runtime-core.js";
+//#region src/frame.d.ts
+/** How long a program may take to answer before the worker is killed. */
+export declare const WATCHDOG_MS = 1000;
+/**
+ * How long a worker that ran a program may sit idle before the runner pings
+ * it, under the same watchdog. A program can start an endless microtask
+ * chain after its reply has gone, from an API that resolves in a task of its
+ * own (`Blob.arrayBuffer()`, `crypto.subtle`); the ping catches that spin
+ * without waiting for the user's next click. Pings stop while the page is
+ * hidden and before the worker has had a program.
+ */
+export declare const HEARTBEAT_MS = 2000;
+/** What the policy check needs from the frame: its document's events, `fetch` and a timer. */
+export interface PolicyScope {
+  addEventListener: (type: "securitypolicyviolation", listener: (event: {
+    originalPolicy: string;
+  }) => void) => void;
+  fetch: (url: string) => Promise<unknown>;
+  removeEventListener: (type: "securitypolicyviolation", listener: (event: {
+    originalPolicy: string;
+  }) => void) => void;
+  setTimeout: (callback: () => void, ms: number) => unknown;
+}
+/**
+ * Resolves true when the policy in force on the frame starts with `expected`.
+ * A middleware that sets the page's policy on every response replaces the
+ * frame's, and the frame would then run without its network lock. The probe
+ * fetches a `data:` URL, which makes no request: the frame's policy refuses
+ * it and reports a violation that carries the policy's text. If the fetch
+ * succeeds, nothing restricts it; if only other policies report it, the
+ * frame's is gone. Serialized with `toString()`, so it must stay
+ * self-contained.
+ */
+export declare function framePolicyInForce(scope: PolicyScope, expected: string, waitMs: number): Promise<boolean>;
+/** Source of the sandbox worker: the runtime, booted with network and code loading removed. */
+export declare const workerSource: string;
+/** The sandbox frame document the server sends on `GET`. */
+export declare function frameDocument(): string;
+//#endregion
+export { createRuntime, frameSecurityPolicy };

package/dist/frame.js

@@ -0,0 +1,258 @@
+import { frameSecurityPolicy } from "./frame-policy.js";
+import { createRuntime } from "./runtime-core.js";
+//#region src/frame.ts
+/** How long a program may take to answer before the worker is killed. */
+const WATCHDOG_MS = 1e3;
+/**
+* How long a worker that ran a program may sit idle before the runner pings
+* it, under the same watchdog. A program can start an endless microtask
+* chain after its reply has gone, from an API that resolves in a task of its
+* own (`Blob.arrayBuffer()`, `crypto.subtle`); the ping catches that spin
+* without waiting for the user's next click. Pings stop while the page is
+* hidden and before the worker has had a program.
+*/
+const HEARTBEAT_MS = 2e3;
+/** Worker globals removed before any program runs: network, timers, messaging, storage, code loading. */
+const LOCKED_GLOBALS = [
+	"fetch",
+	"XMLHttpRequest",
+	"WebSocket",
+	"WebTransport",
+	"EventSource",
+	"importScripts",
+	"setTimeout",
+	"setInterval",
+	"clearTimeout",
+	"clearInterval",
+	"requestAnimationFrame",
+	"queueMicrotask",
+	"Worker",
+	"SharedWorker",
+	"BroadcastChannel",
+	"MessageChannel",
+	"MessagePort",
+	"postMessage",
+	"indexedDB",
+	"caches",
+	"navigator",
+	"location",
+	"eval",
+	"WebAssembly",
+	"Function",
+	"Proxy",
+	"Reflect",
+	"WeakRef",
+	"FinalizationRegistry",
+	"Atomics"
+];
+/**
+* Worker entry point. Serialized with `toString()` like `createRuntime`, so
+* it must stay self-contained.
+*/
+function bootWorker(create, locked) {
+	const scope = globalThis;
+	const post = scope.postMessage.bind(scope);
+	const later = scope.setTimeout.bind(scope);
+	const runtime = create((message) => {
+		later(() => post(message), 0);
+	}, Function);
+	const isPing = (data) => typeof data === "object" && data !== null && "type" in data && data.type === "ping";
+	scope.addEventListener("message", (event) => {
+		const data = event.data;
+		if (isPing(data)) {
+			later(() => post(data), 0);
+			return;
+		}
+		runtime.handle(event.data);
+	});
+	for (const fn of [
+		() => void 0,
+		async () => void 0,
+		function* () {
+			yield;
+		},
+		async function* () {
+			yield;
+		}
+	]) Object.defineProperty(Object.getPrototypeOf(fn), "constructor", {
+		configurable: false,
+		value: void 0,
+		writable: false
+	});
+	for (const builtin of [
+		Object,
+		Array,
+		Function,
+		String,
+		Number,
+		Boolean,
+		Symbol,
+		Map,
+		Set,
+		Promise,
+		RegExp,
+		Date,
+		Error
+	]) {
+		Object.freeze(builtin.prototype);
+		Object.freeze(builtin);
+	}
+	Object.freeze(Math);
+	Object.freeze(JSON);
+	for (const name of locked) {
+		let target = globalThis;
+		while (target !== null) {
+			if (Object.hasOwn(target, name)) try {
+				Object.defineProperty(target, name, {
+					configurable: false,
+					value: void 0,
+					writable: false
+				});
+			} catch {}
+			target = Object.getPrototypeOf(target);
+		}
+	}
+}
+/** How long the frame waits for its own policy to report the probe. */
+const POLICY_WAIT_MS = 1e3;
+/**
+* Resolves true when the policy in force on the frame starts with `expected`.
+* A middleware that sets the page's policy on every response replaces the
+* frame's, and the frame would then run without its network lock. The probe
+* fetches a `data:` URL, which makes no request: the frame's policy refuses
+* it and reports a violation that carries the policy's text. If the fetch
+* succeeds, nothing restricts it; if only other policies report it, the
+* frame's is gone. Serialized with `toString()`, so it must stay
+* self-contained.
+*/
+function framePolicyInForce(scope, expected, waitMs) {
+	return new Promise((resolve) => {
+		const onViolation = (event) => {
+			if (event.originalPolicy.startsWith(expected)) finish(true);
+		};
+		const finish = (inForce) => {
+			scope.removeEventListener("securitypolicyviolation", onViolation);
+			resolve(inForce);
+		};
+		scope.addEventListener("securitypolicyviolation", onViolation);
+		scope.fetch("data:,").then(() => finish(false), () => scope.setTimeout(() => finish(false), waitMs));
+	});
+}
+/**
+* Runs inside the sandbox frame. Serialized with `toString()`, so it must
+* stay self-contained. Starts the worker from the source embedded in the
+* document and relays messages between the page and the worker, one at a
+* time: the next message goes to the worker only after it answered the last.
+* The worker answers only once the work the program queued is done (see
+* `bootWorker`). The watchdog times only the message being processed. A
+* message that takes longer than `timeoutMs` gets the worker restarted, and the messages
+* queued behind it are dropped, since they were meant for the old state.
+* Messages from anything but the parent window are ignored. Nothing starts
+* until `checkPolicy` confirms the frame's own policy is in force; without
+* it the frame tells the page `unprotected` and stays inert.
+*
+* Once the worker has had a message, every `heartbeatMs` it sits idle the
+* runner sends it a ping under the same watchdog, and keeps the answer from
+* the page. A worker spinning between messages is then restarted, and the
+* page told, as if a message had hung. No pings go out while the page is
+* hidden.
+*/
+function bootRunner(workerSource, timeoutMs, heartbeatMs, checkPolicy, policy, policyWaitMs) {
+	const workerUrl = URL.createObjectURL(new Blob([workerSource], { type: "text/javascript" }));
+	let worker = null;
+	let queue = [];
+	let busy = null;
+	/** Whether the worker has had a message, so it may have work running. */
+	let used = false;
+	let heartbeat = null;
+	const ping = {
+		seq: -1,
+		type: "ping"
+	};
+	const toPage = (message) => {
+		window.parent.postMessage(message, "*");
+	};
+	const beat = () => {
+		heartbeat = null;
+		if (busy === null && queue.length === 0 && !document.hidden) {
+			queue.push(ping);
+			next();
+		}
+	};
+	/** Schedules the next ping, if the worker is idle and has run something. */
+	const rest = () => {
+		if (heartbeat === null && used && busy === null && queue.length === 0 && !document.hidden) heartbeat = window.setTimeout(beat, heartbeatMs);
+	};
+	const next = () => {
+		const message = queue.shift();
+		if (busy !== null || worker === null || message === void 0) {
+			if (message !== void 0) queue.unshift(message);
+			return;
+		}
+		const timer = window.setTimeout(() => {
+			worker?.terminate();
+			queue = [];
+			busy = null;
+			start();
+			toPage({
+				seq: message.seq,
+				type: "quarantined"
+			});
+		}, timeoutMs);
+		busy = {
+			seq: message.seq,
+			timer
+		};
+		used = true;
+		worker.postMessage(message);
+	};
+	const start = () => {
+		const created = new Worker(workerUrl);
+		used = false;
+		created.addEventListener("message", (event) => {
+			if (busy !== null && event.data.seq === busy.seq) {
+				window.clearTimeout(busy.timer);
+				busy = null;
+			}
+			if (event.data.seq !== ping.seq) toPage(event.data);
+			next();
+			rest();
+		});
+		worker = created;
+	};
+	const boot = () => {
+		window.addEventListener("message", (event) => {
+			if (event.source !== window.parent) return;
+			queue.push(event.data);
+			next();
+		});
+		document.addEventListener("visibilitychange", rest);
+		start();
+		toPage({ type: "ready" });
+	};
+	checkPolicy({
+		addEventListener: (type, listener) => {
+			document.addEventListener(type, listener);
+		},
+		fetch: (url) => fetch(url),
+		removeEventListener: (type, listener) => {
+			document.removeEventListener(type, listener);
+		},
+		setTimeout: (callback, ms) => window.setTimeout(callback, ms)
+	}, policy, policyWaitMs).then((inForce) => {
+		if (inForce) boot();
+		else toPage({ type: "unprotected" });
+	});
+}
+/** Source of the sandbox worker: the runtime, booted with network and code loading removed. */
+const workerSource = `(${bootWorker.toString()})(${createRuntime.toString()}, ${JSON.stringify(LOCKED_GLOBALS)});`;
+/** Embeds a script in HTML without letting it close the `<script>` element. */
+const scriptText = (code) => code.replaceAll("</", String.raw`<\/`);
+/** The sandbox frame document the server sends on `GET`. */
+function frameDocument() {
+	return `<!doctype html>
+<meta charset="utf-8">
+<script>${scriptText(`(${bootRunner.toString()})(${JSON.stringify(workerSource)}, ${WATCHDOG_MS}, ${HEARTBEAT_MS}, ${framePolicyInForce.toString()}, ${JSON.stringify(frameSecurityPolicy)}, ${POLICY_WAIT_MS});`)}<\/script>`;
+}
+//#endregion
+export { HEARTBEAT_MS, WATCHDOG_MS, createRuntime, frameDocument, framePolicyInForce, frameSecurityPolicy, workerSource };

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+import { frameSecurityPolicy } from "./frame-policy.js";
+import { ChatBlock, ChatBlockStatus, ChildrenKind, ComponentSchema, Diagnostic, DiagnosticFix, Invalidation, JsonValue, Message, NumberPropSchema, PROGRAM_FORMAT, PickleErrorCode, PickleErrorData, ProcedureEntry, ProcedureKind, Program, PropSchema, SessionBody, SessionEvent, SessionOptions, Span, pickleErrorCodes } from "./types.js";
+import { FrameMessage, HostMessage, MutationCall, MutationResult, Op, QueryRead, QueryResult, ROOT_ID, Row, RuntimeError, WireArg, WireValue, WorkerMessage } from "./protocol.js";
+import { parseErrorData, parseInvalidations, parseProgram, parseSessionEvent } from "./parse.js";
+import { MAX_NODES, MAX_OPS, MAX_TEXT, TreeNode, TreeStore, createTreeStore } from "./tree-store.js";
+import { isAllowedImage, isAllowedLink, isImageHostEntry, normalizeImageHost } from "./urls.js";
+export { type ChatBlock, type ChatBlockStatus, type ChildrenKind, type ComponentSchema, type Diagnostic, type DiagnosticFix, type FrameMessage, type HostMessage, type Invalidation, type JsonValue, MAX_NODES, MAX_OPS, MAX_TEXT, type Message, type MutationCall, type MutationResult, type NumberPropSchema, type Op, PROGRAM_FORMAT, type PickleErrorCode, type PickleErrorData, type ProcedureEntry, type ProcedureKind, type Program, type PropSchema, type QueryRead, type QueryResult, ROOT_ID, type Row, type RuntimeError, type SessionBody, type SessionEvent, type SessionOptions, type Span, type TreeNode, type TreeStore, type WireArg, type WireValue, type WorkerMessage, createTreeStore, frameSecurityPolicy, isAllowedImage, isAllowedLink, isImageHostEntry, normalizeImageHost, parseErrorData, parseInvalidations, parseProgram, parseSessionEvent, pickleErrorCodes };

package/dist/index.js

@@ -0,0 +1,7 @@
+import { PROGRAM_FORMAT, pickleErrorCodes } from "./types.js";
+import { ROOT_ID } from "./protocol.js";
+import { frameSecurityPolicy } from "./frame-policy.js";
+import { parseErrorData, parseInvalidations, parseProgram, parseSessionEvent } from "./parse.js";
+import { isAllowedImage, isAllowedLink, isImageHostEntry, normalizeImageHost } from "./urls.js";
+import { MAX_NODES, MAX_OPS, MAX_TEXT, createTreeStore } from "./tree-store.js";
+export { MAX_NODES, MAX_OPS, MAX_TEXT, PROGRAM_FORMAT, ROOT_ID, createTreeStore, frameSecurityPolicy, isAllowedImage, isAllowedLink, isImageHostEntry, normalizeImageHost, parseErrorData, parseInvalidations, parseProgram, parseSessionEvent, pickleErrorCodes };

package/dist/parse.d.ts

@@ -0,0 +1,9 @@
+import { Invalidation, PickleErrorData, Program, SessionEvent } from "./types.js";
+//#region src/parse.d.ts
+export declare function parseErrorData(value: unknown): PickleErrorData | null;
+/** The `invalidate` list of a mutation's reply. */
+export declare function parseInvalidations(value: unknown): ReadonlyArray<Invalidation> | null;
+export declare function parseProgram(value: unknown): Program | null;
+/** One session event from its JSON text, or null when it is not one. */
+export declare function parseSessionEvent(text: string): SessionEvent | null;
+//#endregion

package/dist/parse.js

@@ -0,0 +1,150 @@
+import { pickleErrorCodes } from "./types.js";
+//#region src/parse.ts
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const isString = (value) => typeof value === "string";
+const isStringList = (value) => Array.isArray(value) && value.every(isString);
+function recordOf(value, item) {
+	if (!isRecord(value)) return null;
+	const out = {};
+	for (const [key, entry] of Object.entries(value)) {
+		const parsed = item(entry);
+		if (parsed === null) return null;
+		out[key] = parsed;
+	}
+	return out;
+}
+const isErrorCode = (value) => pickleErrorCodes.some((code) => code === value);
+function parseErrorData(value) {
+	if (!isRecord(value) || !isErrorCode(value.code) || !isString(value.message)) return null;
+	return {
+		code: value.code,
+		message: value.message
+	};
+}
+function parseInvalidation(value) {
+	if (!isRecord(value) || !isString(value.name)) return null;
+	if (!("input" in value)) return { name: value.name };
+	return {
+		input: value.input,
+		name: value.name
+	};
+}
+/** The `invalidate` list of a mutation's reply. */
+function parseInvalidations(value) {
+	if (!Array.isArray(value)) return null;
+	const out = [];
+	for (const entry of value) {
+		const parsed = parseInvalidation(entry);
+		if (parsed === null) return null;
+		out.push(parsed);
+	}
+	return out;
+}
+function parsePropSchema(value) {
+	if (!isRecord(value)) return null;
+	switch (value.kind) {
+		case "boolean":
+		case "handler":
+		case "image":
+		case "link":
+		case "list":
+		case "string": return { kind: value.kind };
+		case "enum": return isStringList(value.values) ? {
+			kind: "enum",
+			values: value.values
+		} : null;
+		case "number": {
+			const schema = { kind: "number" };
+			if (typeof value.min === "number") schema.min = value.min;
+			if (typeof value.max === "number") schema.max = value.max;
+			return schema;
+		}
+		default: return null;
+	}
+}
+const isChildrenKind = (value) => value === "block" || value === "inline" || value === "none";
+function parseComponentSchema(value) {
+	if (!isRecord(value) || !isChildrenKind(value.children)) return null;
+	const props = recordOf(value.props, parsePropSchema);
+	return props === null ? null : {
+		children: value.children,
+		props
+	};
+}
+function parseProcedure(value) {
+	if (!isRecord(value) || value.kind !== "query" && value.kind !== "mutation" && value.kind !== "action" || !isStringList(value.invalidates)) return null;
+	return {
+		invalidates: value.invalidates,
+		kind: value.kind
+	};
+}
+function parseProgram(value) {
+	if (!isRecord(value) || value.format !== 1 || !isString(value.code) || !isStringList(value.imageHosts)) return null;
+	const components = recordOf(value.components, parseComponentSchema);
+	const procedures = recordOf(value.procedures, parseProcedure);
+	const prose = recordOf(value.prose, (entry) => isString(entry) ? entry : null);
+	if (components === null || procedures === null || prose === null) return null;
+	return {
+		code: value.code,
+		components,
+		format: 1,
+		imageHosts: value.imageHosts,
+		procedures,
+		prose
+	};
+}
+function parseDiagnostic(value) {
+	if (!isRecord(value) || !isString(value.code) || !isString(value.message) || value.severity !== "error" && value.severity !== "warning" && value.severity !== "info" && value.severity !== "hint" || !isRecord(value.span) || typeof value.span.line !== "number") return null;
+	return {
+		code: value.code,
+		message: value.message,
+		severity: value.severity,
+		span: { line: value.span.line }
+	};
+}
+/** The diagnostics that parse; one the browser cannot read is skipped, not the event. */
+function parseDiagnostics(value) {
+	if (!Array.isArray(value)) return null;
+	return value.flatMap((entry) => {
+		const parsed = parseDiagnostic(entry);
+		return parsed === null ? [] : [parsed];
+	});
+}
+/** One session event from its JSON text, or null when it is not one. */
+function parseSessionEvent(text) {
+	let value;
+	try {
+		value = JSON.parse(text);
+	} catch {
+		return null;
+	}
+	if (!isRecord(value)) return null;
+	if (value.type === "error") {
+		const error = parseErrorData(value.error);
+		return error === null ? null : {
+			error,
+			type: "error"
+		};
+	}
+	const diagnostics = parseDiagnostics(value.diagnostics);
+	if (diagnostics === null || typeof value.revision !== "number") return null;
+	if (value.type === "program") {
+		const program = parseProgram(value.program);
+		return program === null ? null : {
+			diagnostics,
+			fresh: value.fresh === true,
+			program,
+			revision: value.revision,
+			type: "program"
+		};
+	}
+	if (value.type === "done" && isString(value.source)) return {
+		diagnostics,
+		revision: value.revision,
+		source: value.source,
+		type: "done"
+	};
+	return null;
+}
+//#endregion
+export { parseErrorData, parseInvalidations, parseProgram, parseSessionEvent };