@monimesl/dot-dash 0.1.0-alpha.4 → 0.1.0-alpha.40

package/dist/index.js

@@ -1,113 +1,295 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
-import { HostError, HostError as HostError$1, callHost, createHostRequest } from "@monimesl/dot-core";
+import { DEFAULT_DASH_API_VERSION, HostError, HostError as DashError, callHost, createHostRequest, offersDashApiVersion } from "@monimesl/dot-core";
+//#region src/api-versions.ts
+const DASH_API_VERSION = "1.0";
+const DASH_API_SINCE = {
+	"account.signIn": "1.0",
+	"contacts.pickPhone": "1.0",
+	"crypto.hmac": "1.0",
+	"crypto.randomBytes": "1.0",
+	"crypto.randomUUID": "1.0",
+	"crypto.sha256": "1.0",
+	"crypto.sha512": "1.0",
+	"dot.close": "1.0",
+	"media.pickFile": "1.0",
+	"media.pickPhoto": "1.0",
+	"media.scanCode": "1.0",
+	"network.http.download": "1.0",
+	"network.http.request": "1.0",
+	"network.http.upload": "1.0",
+	"network.status": "1.0",
+	"payments.get": "1.0",
+	"payments.request": "1.0",
+	"storage.cache.clear": "1.0",
+	"storage.cache.exists": "1.0",
+	"storage.cache.get": "1.0",
+	"storage.cache.keys": "1.0",
+	"storage.cache.remove": "1.0",
+	"storage.cache.set": "1.0",
+	"storage.file.copy": "1.0",
+	"storage.file.createFolder": "1.0",
+	"storage.file.list": "1.0",
+	"storage.file.move": "1.0",
+	"storage.file.open": "1.0",
+	"storage.file.read": "1.0",
+	"storage.file.remove": "1.0",
+	"storage.file.save": "1.0",
+	"storage.file.stat": "1.0",
+	"storage.file.usage": "1.0",
+	"storage.file.write": "1.0",
+	"storage.secret.clear": "1.0",
+	"storage.secret.get": "1.0",
+	"storage.secret.remove": "1.0",
+	"storage.secret.set": "1.0",
+	"system.brightness": "1.0",
+	"system.copyText": "1.0",
+	"system.delay": "1.0",
+	"system.dial": "1.0",
+	"system.info": "1.0",
+	"system.keepAwake": "1.0",
+	"system.openUrl": "1.0",
+	"system.share": "1.0",
+	"system.torch": "1.0",
+	"system.vibrate": "1.0",
+	"ui.alert": "1.0",
+	"ui.pickDate": "1.0",
+	"ui.pickTime": "1.0"
+};
+let hostApiVersions = [DEFAULT_DASH_API_VERSION];
+let dotMinApiVersion;
+const checkedFeatures = /* @__PURE__ */ new Set();
+const warnedFeatures = /* @__PURE__ */ new Set();
+function useHostDashApiVersions(versions) {
+	hostApiVersions = versions;
+}
+function warnAboveDashApiVersion(minApiVersion) {
+	dotMinApiVersion = minApiVersion;
+}
+/**
+* Whether the Dash the dot runs in has `feature`: a call, such as "contacts.pickPhone", or a field
+* added to a call later. Check it before using one that's newer than the dot's minApiVersion.
+* @since 1.0
+*/
+function supports(feature) {
+	checkedFeatures.add(feature);
+	const since = sinceOf(feature);
+	return since !== void 0 && offersDashApiVersion(hostApiVersions, since);
+}
+function warnIfNewerThanDot(method, params) {
+	if (dotMinApiVersion === void 0) return;
+	const callName = method.replace(/^dash\./, "");
+	for (const feature of [callName, ...fieldsSent(callName, params)]) {
+		const since = sinceOf(feature);
+		if (since === void 0) continue;
+		if (checkedFeatures.has(feature) || warnedFeatures.has(feature)) continue;
+		if (offersDashApiVersion([dotMinApiVersion], since)) continue;
+		warnedFeatures.add(feature);
+		console.warn(`dash.${feature} came in Dash API ${since}, but this dot's minApiVersion is ${dotMinApiVersion}, so older Dash doesn't have it. Raise "minApiVersion" in dot.json, or check dash.supports('${feature}') first.`);
+	}
+}
+function sinceOf(feature) {
+	const table = DASH_API_SINCE;
+	return Object.hasOwn(table, feature) ? table[feature] : void 0;
+}
+function fieldsSent(callName, params) {
+	if (typeof params !== "object" || params === null) return [];
+	return Object.keys(params).map((field) => `${callName}.${field}`).filter((feature) => sinceOf(feature) !== void 0);
+}
+//#endregion
 //#region src/call.ts
 function call(method, params, options = {}) {
+	warnIfNewerThanDot(method, params);
 	return callHost(method, params, options);
 }
 //#endregion
-//#region src/file/index.ts
-var file_exports = /* @__PURE__ */ __exportAll({
-	copy: () => copy,
-	createFolder: () => createFolder,
-	list: () => list,
-	move: () => move,
-	open: () => open,
-	read: () => read,
-	remove: () => remove,
-	save: () => save,
-	stat: () => stat,
-	usage: () => usage,
-	write: () => write
+//#region src/account/index.ts
+var account_exports = /* @__PURE__ */ __exportAll({ signIn: () => signIn });
+function signIn(options, callOptions) {
+	const params = {
+		mode: options.mode,
+		nonce: options.nonce ?? ""
+	};
+	if (options.mode === "oidc" && options.scopes) params.scopes = options.scopes;
+	return call("dash.account.signIn", params, callOptions);
+}
+//#endregion
+//#region src/contacts/pick-phone.ts
+/**
+* Shows the phone's contacts so the person chooses one phone number, such as who to send money to.
+* Needs the `contacts` permission. The dot sees only the chosen contact. Rejects with `cancelled` if
+* the person closes it.
+* @since 1.0
+*/
+function pickPhone(callOptions) {
+	return call("dash.contacts.pickPhone", {}, callOptions);
+}
+//#endregion
+//#region src/contacts/index.ts
+var contacts_exports = /* @__PURE__ */ __exportAll({ pickPhone: () => pickPhone });
+//#endregion
+//#region src/crypto/index.ts
+var crypto_exports = /* @__PURE__ */ __exportAll({
+	hmac: () => hmac,
+	randomBytes: () => randomBytes,
+	randomUUID: () => randomUUID,
+	sha256: () => sha256,
+	sha512: () => sha512
 });
-function read(path, options = {}, callOptions) {
-	return call("dash.file.read", {
-		path,
-		...options
-	}, callOptions);
+/** @since 1.0 */
+function sha256(data, options = {}, callOptions) {
+	return call("dash.crypto.sha256", wireInput(data, options), callOptions);
 }
-function write(path, data, options = {}, callOptions) {
-	return call("dash.file.write", {
-		path,
-		data,
-		...options
-	}, callOptions);
+/** @since 1.0 */
+function sha512(data, options = {}, callOptions) {
+	return call("dash.crypto.sha512", wireInput(data, options), callOptions);
 }
-function stat(path, callOptions) {
-	return call("dash.file.stat", { path }, callOptions);
+/**
+* Signs `data` with `key`, as HMAC-SHA256 or HMAC-SHA512, such as
+* `hmac({ algorithm: 'sha256', key, data })`.
+* @since 1.0
+*/
+function hmac(options, callOptions) {
+	const wireKey = valueAndEncoding(options.key);
+	return call("dash.crypto.hmac", {
+		...wireInput(options.data, options),
+		algorithm: options.algorithm,
+		key: wireKey.value,
+		keyEncoding: wireKey.encoding
+	}, callOptions);
 }
-function list(path = "", options = {}, callOptions) {
-	return call("dash.file.list", {
-		path,
-		...options
+/**
+* `count` secure random bytes, from 1 to 1024, such as for a nonce.
+* @since 1.0
+*/
+function randomBytes(count, options = {}, callOptions) {
+	return call("dash.crypto.randomBytes", {
+		count,
+		as: outputEncoding(options)
 	}, callOptions);
 }
-function createFolder(path, callOptions) {
-	return call("dash.file.createFolder", { path }, callOptions);
+/**
+* A random version 4 UUID, such as "3f0e5c3a-6d1b-4c8e-9a2f-1b7d4e6a9c05".
+* @since 1.0
+*/
+function randomUUID(callOptions) {
+	return call("dash.crypto.randomUUID", {}, callOptions);
 }
-function move(from, to, options = {}, callOptions) {
-	return call("dash.file.move", {
-		from,
-		to,
-		...options
-	}, callOptions);
+function wireInput(data, options) {
+	const { value, encoding } = valueAndEncoding(data);
+	return {
+		data: value,
+		dataEncoding: encoding,
+		as: outputEncoding(options)
+	};
 }
-function copy(from, to, options = {}, callOptions) {
-	return call("dash.file.copy", {
-		from,
-		to,
-		...options
-	}, callOptions);
+function outputEncoding(options) {
+	return options.as ?? "hex";
 }
-function remove(path, options = {}, callOptions) {
-	return call("dash.file.remove", {
-		path,
-		...options
-	}, callOptions);
+function valueAndEncoding(input) {
+	if (typeof input === "string") return {
+		value: input,
+		encoding: "text"
+	};
+	return {
+		value: input.base64,
+		encoding: "base64"
+	};
 }
-function save(file, path, options = {}, callOptions) {
-	return call("dash.file.save", {
-		file: typeof file === "string" ? file : file.id,
-		path,
-		...options
-	}, callOptions);
+//#endregion
+//#region src/dot/index.ts
+var dot_exports = /* @__PURE__ */ __exportAll({ close: () => close });
+/**
+* Closes the dot, as going back from its first page does. Calls still running are cancelled.
+* @since 1.0
+*/
+function close(callOptions) {
+	return call("dash.dot.close", {}, callOptions);
 }
-function open(path, callOptions) {
-	return call("dash.file.open", { path }, callOptions);
+//#endregion
+//#region src/media/pick-file.ts
+/**
+* Lets the person choose a file from their phone, of at most 25 MB. Needs the `files` permission.
+* Rejects with `cancelled` if they close the picker, and with `invalid` for a larger file. Like a
+* download, it lasts until the dot closes, so `dash.storage.file.save` it to keep it.
+* @since 1.0
+*/
+function pickFile(options = {}, callOptions) {
+	const params = {};
+	if (options.types) params.types = options.types;
+	return call("dash.media.pickFile", params, callOptions);
 }
-function usage(callOptions) {
-	return call("dash.file.usage", {}, callOptions);
+//#endregion
+//#region src/media/pick-photo.ts
+/**
+* Lets the person choose a photo or take one. Resolves with it as a JPEG of at most 2048 pixels on its
+* longest side, without its location or other details. Rejects with `cancelled` if they close the
+* picker, and with `unsupported` on a device without a camera. Save it with `dash.storage.file.save`
+* to keep it after the dot closes.
+* @since 1.0
+*/
+function pickPhoto(options, callOptions) {
+	return call("dash.media.pickPhoto", { source: options.source }, callOptions);
+}
+//#endregion
+//#region src/media/scan-code.ts
+/**
+* Opens Dash's scanner until it reads a QR code. Needs the `camera` permission. Rejects with
+* `cancelled` if the person closes it, and with `unsupported` where Dash has no scanner.
+* @since 1.0
+*/
+function scanCode(callOptions) {
+	return call("dash.media.scanCode", {}, callOptions);
 }
 //#endregion
+//#region src/media/index.ts
+var media_exports = /* @__PURE__ */ __exportAll({
+	pickFile: () => pickFile,
+	pickPhoto: () => pickPhoto,
+	scanCode: () => scanCode
+});
+//#endregion
 //#region src/network/http.ts
 var http_exports = /* @__PURE__ */ __exportAll({
 	download: () => download,
-	request: () => request,
+	request: () => request$1,
 	upload: () => upload
 });
-function request(options, callOptions) {
-	const { as, ...request } = options;
-	return readBody(call("dash.network.http.request", wireRequest(request, as), callOptions), as);
+/**
+* Like fetch, resolves with any response, even a 404. An object body is sent as JSON.
+* @since 1.0
+*/
+function request$1(options, callOptions) {
+	const { as: readAs, ...request } = options;
+	return readBody(call("dash.network.http.request", wireRequest(request, readAs), callOptions), readAs);
 }
+/**
+* Saves a 2xx response's body, up to 256 MB, to a temporary file.
+* @since 1.0
+*/
 function download(options, callOptions) {
 	return call("dash.network.http.download", wireRequest(options), callOptions);
 }
+/**
+* Sends the dot's files as a multipart form.
+* @since 1.0
+*/
 function upload(options, callOptions) {
-	const { as, ...request } = options;
-	const files = request.files.map(({ file, ...rest }) => ({
-		...rest,
-		file: typeof file === "string" ? file : file.id
+	const { as: readAs, ...request } = options;
+	const files = request.files.map((upload) => ({
+		...upload,
+		file: upload.file.id
 	}));
 	const params = {
 		...request,
 		files
 	};
-	if (as === "json") params.headers = withDefaultHeader(request.headers, "Accept", "application/json");
-	return readBody(call("dash.network.http.upload", params, callOptions), as);
+	if (readAs === "json") params.headers = withDefaultHeader(request.headers, "Accept", "application/json");
+	return readBody(call("dash.network.http.upload", params, callOptions), readAs);
 }
-function wireRequest(request, as) {
+function wireRequest(request, readAs) {
 	let headers = request.headers;
 	let body;
-	if (as === "json") headers = withDefaultHeader(headers, "Accept", "application/json");
+	if (readAs === "json") headers = withDefaultHeader(headers, "Accept", "application/json");
 	if (typeof request.body === "string") body = request.body;
 	else if (request.body !== void 0) {
 		headers = withDefaultHeader(headers, "Content-Type", "application/json");
@@ -120,15 +302,16 @@ function wireRequest(request, as) {
 	};
 }
 function withDefaultHeader(headers, name, value) {
+	if (headers === void 0) return { [name]: value };
 	const lowerName = name.toLowerCase();
-	if (headers && Object.keys(headers).some((existing) => existing.toLowerCase() === lowerName)) return headers;
+	if (Object.keys(headers).some((existing) => existing.toLowerCase() === lowerName)) return headers;
 	return {
 		...headers,
 		[name]: value
 	};
 }
-function readBody(response, as) {
-	if (as !== "json") return response;
+function readBody(response, readAs) {
+	if (readAs !== "json") return response;
 	const parsed = response.then((result) => ({
 		...result,
 		body: parseJson(result)
@@ -140,54 +323,356 @@ function parseJson({ status, statusText, body }) {
 		return JSON.parse(body);
 	} catch (error) {
 		const message = error instanceof Error ? error.message : String(error);
-		throw new HostError$1("failed", `The response (${status} ${statusText}) isn't JSON: ${message}`);
+		throw new HostError("failed", `The response (${status} ${statusText}) isn't JSON: ${message}`);
 	}
 }
 //#endregion
+//#region src/network/status.ts
+/**
+* Whether the phone is online now, and how. It can still be online without reaching a server.
+* @since 1.0
+*/
+function status(callOptions) {
+	return call("dash.network.status", {}, callOptions);
+}
+//#endregion
 //#region src/network/index.ts
-var network_exports = /* @__PURE__ */ __exportAll({ http: () => http_exports });
+var network_exports = /* @__PURE__ */ __exportAll({
+	http: () => http_exports,
+	status: () => status
+});
+//#endregion
+//#region src/payments/payments.ts
+/**
+* Opens Dash's payment sheet for `order`, where the person picks one of `methods` and pays the
+* Space that owns the dot. Needs `payments` in dot.json's permissions. Monime checks the request
+* before the sheet opens: an order it won't take, such as one below its smallest amount, rejects
+* with `invalid`, a dot or Space it won't take payments for rejects with `denied`, and `failed`
+* means Dash couldn't reach Monime. If a method fails, the sheet stays open for the person to try
+* again or pick another. Once they pick a method, it resolves with how the payment ended:
+* `completed`, `pending` while it's still on its way, `expired`, or `cancelled` if the person
+* closed the sheet. Before that, it rejects with `cancelled` if the person closes the sheet, or
+* `timeout` if Dash's time runs out. A payment already under way carries on after `cancel()`: read
+* it later with `get`.
+* @since 1.0
+*/
+function request(options, callOptions) {
+	const withoutTimeout = { ...callOptions };
+	delete withoutTimeout.timeout;
+	return call("dash.payments.request", options, withoutTimeout);
+}
+/**
+* The payment for the order with this reference, such as to check a pending one later, or after
+* the dot opens again. Undefined if this dot never asked for it, or the person never picked a
+* method. Needs `payments` in dot.json's permissions.
+* @since 1.0
+*/
+function get$2(reference, callOptions) {
+	const response = call("dash.payments.get", { reference }, callOptions);
+	const found = response.then((result) => result ?? void 0);
+	return createHostRequest(found, () => response.cancel());
+}
+//#endregion
+//#region src/payments/index.ts
+var payments_exports = /* @__PURE__ */ __exportAll({
+	get: () => get$2,
+	request: () => request
+});
+//#endregion
+//#region src/storage/cache.ts
+var cache_exports = /* @__PURE__ */ __exportAll({
+	clear: () => clear$1,
+	exists: () => exists,
+	get: () => get$1,
+	keys: () => keys,
+	remove: () => remove$2,
+	set: () => set$1
+});
+/**
+* Resolves with null for a missing or expired key.
+* @since 1.0
+*/
+function get$1(key, callOptions) {
+	return call("dash.storage.cache.get", { key }, callOptions);
+}
+/** @since 1.0 */
+function set$1(key, value, options = {}, callOptions) {
+	return call("dash.storage.cache.set", {
+		key,
+		value,
+		...options
+	}, callOptions);
+}
+/** @since 1.0 */
+function remove$2(key, callOptions) {
+	return call("dash.storage.cache.remove", { key }, callOptions);
+}
+/** @since 1.0 */
+function exists(key, callOptions) {
+	return call("dash.storage.cache.exists", { key }, callOptions);
+}
+/**
+* The keys, sorted.
+* @since 1.0
+*/
+function keys(callOptions) {
+	return call("dash.storage.cache.keys", {}, callOptions);
+}
+/** @since 1.0 */
+function clear$1(callOptions) {
+	return call("dash.storage.cache.clear", {}, callOptions);
+}
+//#endregion
+//#region src/storage/file.ts
+var file_exports = /* @__PURE__ */ __exportAll({
+	copy: () => copy,
+	createFolder: () => createFolder,
+	list: () => list,
+	move: () => move,
+	open: () => open,
+	read: () => read,
+	remove: () => remove$1,
+	save: () => save,
+	stat: () => stat,
+	usage: () => usage,
+	write: () => write
+});
+/**
+* Reads a file of up to 5 MB.
+* @since 1.0
+*/
+function read(path, options = {}, callOptions) {
+	return call("dash.storage.file.read", {
+		path,
+		...options
+	}, callOptions);
+}
+/**
+* Creates any missing folders above the file.
+* @since 1.0
+*/
+function write(path, data, options = {}, callOptions) {
+	return call("dash.storage.file.write", {
+		path,
+		data,
+		...options
+	}, callOptions);
+}
+/** @since 1.0 */
+function stat(path, callOptions) {
+	return call("dash.storage.file.stat", { path }, callOptions);
+}
+/**
+* Sorted by path.
+* @since 1.0
+*/
+function list(path = "", options = {}, callOptions) {
+	return call("dash.storage.file.list", {
+		path,
+		...options
+	}, callOptions);
+}
+/** @since 1.0 */
+function createFolder(path, callOptions) {
+	return call("dash.storage.file.createFolder", { path }, callOptions);
+}
+/** @since 1.0 */
+function move(from, to, options = {}, callOptions) {
+	return call("dash.storage.file.move", {
+		from,
+		to,
+		...options
+	}, callOptions);
+}
+/** @since 1.0 */
+function copy(from, to, options = {}, callOptions) {
+	return call("dash.storage.file.copy", {
+		from,
+		to,
+		...options
+	}, callOptions);
+}
+/**
+* Removing a folder that isn't empty needs `recursive`.
+* @since 1.0
+*/
+function remove$1(path, options = {}, callOptions) {
+	return call("dash.storage.file.remove", {
+		path,
+		...options
+	}, callOptions);
+}
+/**
+* Keeps a temporary file, such as a download, at `path`.
+* @since 1.0
+*/
+function save(file, path, options = {}, callOptions) {
+	return call("dash.storage.file.save", {
+		file: file.id,
+		path,
+		...options
+	}, callOptions);
+}
+/**
+* A stored file as a DotFile, to show with its `url` or send with `http.upload`.
+* @since 1.0
+*/
+function open(path, callOptions) {
+	return call("dash.storage.file.open", { path }, callOptions);
+}
+/** @since 1.0 */
+function usage(callOptions) {
+	return call("dash.storage.file.usage", {}, callOptions);
+}
+//#endregion
+//#region src/storage/secret.ts
+var secret_exports = /* @__PURE__ */ __exportAll({
+	clear: () => clear,
+	get: () => get,
+	remove: () => remove,
+	set: () => set
+});
+/** @since 1.0 */
+function get(key, callOptions) {
+	return call("dash.storage.secret.get", { key }, callOptions);
+}
+/** @since 1.0 */
+function set(key, value, callOptions) {
+	return call("dash.storage.secret.set", {
+		key,
+		value
+	}, callOptions);
+}
+/** @since 1.0 */
+function remove(key, callOptions) {
+	return call("dash.storage.secret.remove", { key }, callOptions);
+}
+/** @since 1.0 */
+function clear(callOptions) {
+	return call("dash.storage.secret.clear", {}, callOptions);
+}
+//#endregion
+//#region src/storage/index.ts
+var storage_exports = /* @__PURE__ */ __exportAll({
+	cache: () => cache_exports,
+	file: () => file_exports,
+	secret: () => secret_exports
+});
 //#endregion
 //#region src/system/clipboard.ts
+/** @since 1.0 */
 function copyText(text, callOptions) {
 	return call("dash.system.copyText", { text }, callOptions);
 }
 //#endregion
 //#region src/system/delay.ts
+/**
+* Resolves after `milliseconds`. The host keeps the time, since a dot's logic has no timers.
+* @since 1.0
+*/
 function delay(milliseconds, callOptions) {
 	return call("dash.system.delay", { milliseconds }, callOptions);
 }
 //#endregion
+//#region src/system/dial.ts
+/**
+* Opens the phone's dialer with `number` ready, such as "+232 76 123456" or a USSD code such as
+* "*715#". The person taps Call. Spaces and dashes are fine; anything else but digits, +, * and #
+* rejects with `invalid`. For a code, Dash asks the person first, and rejects with `cancelled` if
+* they say no. Codes that set up call forwarding, such as "**21*…#", reject with `denied`.
+* @since 1.0
+*/
+function dial(number, callOptions) {
+	return call("dash.system.dial", { number }, callOptions);
+}
+//#endregion
 //#region src/system/haptics.ts
+/**
+* Plays a short vibration. Resolves once it's done.
+* @since 1.0
+*/
 function vibrate(options = {}, callOptions) {
 	return call("dash.system.vibrate", { style: options.style ?? "medium" }, callOptions);
 }
 //#endregion
+//#region src/system/info.ts
+/**
+* The phone and the Dash the dot runs in. It has nothing that identifies the person or the phone.
+* @since 1.0
+*/
+function info(callOptions) {
+	return call("dash.system.info", {}, callOptions);
+}
+//#endregion
+//#region src/system/open-url.ts
+/**
+* Opens an https address in the device's browser. Any other address rejects with `invalid`.
+* @since 1.0
+*/
+function openUrl(url, callOptions) {
+	return call("dash.system.openUrl", { url }, callOptions);
+}
+//#endregion
+//#region src/system/screen.ts
+/**
+* Keeps the screen from dimming and locking while the dot shows, such as while a ticket's QR code is
+* up. Dash undoes it when the dot closes.
+* @since 1.0
+*/
+function keepAwake(on, callOptions) {
+	return call("dash.system.keepAwake", { on }, callOptions);
+}
+/**
+* `max` makes the screen as bright as it goes, so a scanner can read a QR code on it, and `normal`
+* puts it back. Dash puts it back too when the dot closes or the person leaves the app.
+* @since 1.0
+*/
+function brightness(level, callOptions) {
+	return call("dash.system.brightness", { level }, callOptions);
+}
+//#endregion
 //#region src/system/share.ts
+/**
+* Opens the device's share sheet. Resolves once it shows.
+* @since 1.0
+*/
 function share(options, callOptions) {
-	const { file, ...rest } = options;
-	if (file === void 0) return call("dash.system.share", rest, callOptions);
-	const id = typeof file === "string" ? file : file.id;
+	const { file, ...content } = options;
+	if (file === void 0) return call("dash.system.share", content, callOptions);
 	return call("dash.system.share", {
-		...rest,
-		file: id
+		...content,
+		file: file.id
 	}, callOptions);
 }
 //#endregion
 //#region src/system/torch.ts
-function torch(state, callOptions) {
-	return call("dash.system.torch", { state }, callOptions);
+/**
+* Turns the torch on or off. Rejects with `unsupported` on a device without one.
+* @since 1.0
+*/
+function torch(on, callOptions) {
+	return call("dash.system.torch", { on }, callOptions);
 }
 //#endregion
 //#region src/system/index.ts
 var system_exports = /* @__PURE__ */ __exportAll({
+	brightness: () => brightness,
 	copyText: () => copyText,
 	delay: () => delay,
+	dial: () => dial,
+	info: () => info,
+	keepAwake: () => keepAwake,
+	openUrl: () => openUrl,
 	share: () => share,
 	torch: () => torch,
 	vibrate: () => vibrate
 });
 //#endregion
 //#region src/ui/dialogs.ts
+/**
+* Shows a native alert. Resolves with the action the person chose.
+* @since 1.0
+*/
 function alert(options, callOptions) {
 	const actions = options.actions ?? [{
 		id: "ok",
@@ -199,31 +684,234 @@ function alert(options, callOptions) {
 	}, callOptions);
 }
 //#endregion
+//#region src/ui/pickers.ts
+/**
+* Opens the phone's own calendar. Resolves with the chosen date, such as "2026-10-24", or rejects
+* with `cancelled` if the person closes it.
+* @since 1.0
+*/
+function pickDate(options = {}, callOptions) {
+	return call("dash.ui.pickDate", options, callOptions);
+}
+/**
+* Opens the phone's own clock. Resolves with the chosen time in 24 hours, such as "19:30", or
+* rejects with `cancelled` if the person closes it.
+* @since 1.0
+*/
+function pickTime(options = {}, callOptions) {
+	return call("dash.ui.pickTime", options, callOptions);
+}
+//#endregion
 //#region src/ui/index.ts
-var ui_exports = /* @__PURE__ */ __exportAll({ alert: () => alert });
+var ui_exports = /* @__PURE__ */ __exportAll({
+	alert: () => alert,
+	pickDate: () => pickDate,
+	pickTime: () => pickTime
+});
+//#endregion
+//#region src/utils/encoding.ts
+const BASE64_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+const HEX_PATTERN = /^(?:[0-9a-fA-F]{2})*$/;
+const base64 = {
+	encode(text) {
+		return bytesToBase64(utf8Bytes(text));
+	},
+	decode(encoded) {
+		return utf8Text(base64ToBytes(encoded));
+	}
+};
+const hex = {
+	encode(text) {
+		return utf8Bytes(text).map((byte) => byte.toString(16).padStart(2, "0")).join("");
+	},
+	decode(encoded) {
+		if (!HEX_PATTERN.test(encoded)) throw new Error(`"${encoded.slice(0, 20)}" isn't hex. Use pairs of 0-9 and a-f.`);
+		const bytes = [];
+		for (let index = 0; index < encoded.length; index += 2) bytes.push(parseInt(encoded.slice(index, index + 2), 16));
+		return utf8Text(bytes);
+	}
+};
+function bytesToBase64(bytes) {
+	let encoded = "";
+	for (let index = 0; index < bytes.length; index += 3) {
+		const group = bytes.slice(index, index + 3);
+		const bits = (group[0] ?? 0) << 16 | (group[1] ?? 0) << 8 | (group[2] ?? 0);
+		const sextets = [
+			bits >> 18 & 63,
+			bits >> 12 & 63,
+			bits >> 6 & 63,
+			bits & 63
+		];
+		const characterCount = group.length + 1;
+		for (const sextet of sextets.slice(0, characterCount)) encoded += BASE64_ALPHABET[sextet];
+		encoded += "=".repeat(4 - characterCount);
+	}
+	return encoded;
+}
+function base64ToBytes(encoded) {
+	if (!isBase64(encoded)) throw new Error(`"${encoded.slice(0, 20)}" isn't base64.`);
+	const bytes = [];
+	for (let index = 0; index < encoded.length; index += 4) {
+		const characters = encoded.slice(index, index + 4);
+		let bits = 0;
+		let padding = 0;
+		for (const character of characters) {
+			bits <<= 6;
+			if (character === "=") padding += 1;
+			else bits |= BASE64_ALPHABET.indexOf(character);
+		}
+		bytes.push(bits >> 16 & 255);
+		if (padding < 2) bytes.push(bits >> 8 & 255);
+		if (padding < 1) bytes.push(bits & 255);
+	}
+	return bytes;
+}
+function isBase64(encoded) {
+	if (encoded.length % 4 !== 0) return false;
+	let padding = 0;
+	if (encoded.endsWith("==")) padding = 2;
+	else if (encoded.endsWith("=")) padding = 1;
+	for (let index = 0; index < encoded.length - padding; index += 1) if (BASE64_ALPHABET.indexOf(encoded[index]) === -1) return false;
+	return true;
+}
+function utf8Bytes(text) {
+	const bytes = [];
+	for (const character of text) {
+		const codePoint = character.codePointAt(0);
+		if (codePoint < 128) bytes.push(codePoint);
+		else if (codePoint < 2048) bytes.push(192 | codePoint >> 6, 128 | codePoint & 63);
+		else if (codePoint < 65536) bytes.push(224 | codePoint >> 12, 128 | codePoint >> 6 & 63, 128 | codePoint & 63);
+		else bytes.push(240 | codePoint >> 18, 128 | codePoint >> 12 & 63, 128 | codePoint >> 6 & 63, 128 | codePoint & 63);
+	}
+	return bytes;
+}
+const MAX_CODE_POINT = 1114111;
+const MIN_CODE_POINT_FOR_LENGTH = [
+	0,
+	0,
+	128,
+	2048,
+	65536
+];
+function utf8Text(bytes) {
+	let text = "";
+	let index = 0;
+	while (index < bytes.length) {
+		const first = bytes[index];
+		const length = sequenceLength(first);
+		const continuation = bytes.slice(index + 1, index + length);
+		if (length === 0 || !isCompleteContinuation(continuation, length)) {
+			text += "�";
+			index += 1;
+			continue;
+		}
+		let codePoint = firstByteBits(first, length);
+		for (const byte of continuation) codePoint = codePoint << 6 | byte & 63;
+		const isPastLastCharacter = codePoint > MAX_CODE_POINT;
+		const isSpelledTooLong = codePoint < MIN_CODE_POINT_FOR_LENGTH[length];
+		if (isPastLastCharacter || isSpelledTooLong || codePoint >= 55296 && codePoint <= 57343) {
+			text += "�";
+			index += 1;
+			continue;
+		}
+		text += String.fromCodePoint(codePoint);
+		index += length;
+	}
+	return text;
+}
+function sequenceLength(first) {
+	if (first < 128) return 1;
+	if (first >= 240) return 4;
+	if (first >= 224) return 3;
+	if (first >= 192) return 2;
+	return 0;
+}
+function isCompleteContinuation(continuation, length) {
+	if (continuation.length !== length - 1) return false;
+	return continuation.every((byte) => (byte & 192) === 128);
+}
+function firstByteBits(first, length) {
+	if (length === 1) return first;
+	return first & 255 >> length + 1;
+}
+//#endregion
+//#region src/utils/index.ts
+var utils_exports = /* @__PURE__ */ __exportAll({
+	base64: () => base64,
+	hex: () => hex
+});
 //#endregion
 //#region src/tracked.ts
 function tracked(group, track) {
 	const copy = {};
 	for (const [name, member] of Object.entries(group)) if (typeof member === "function") {
-		const start = member;
+		const startCall = member;
 		copy[name] = (...args) => {
-			const request = start(...args);
-			track(request);
-			return request;
+			const result = startCall(...args);
+			if (result instanceof Promise) track(result);
+			return result;
 		};
 	} else copy[name] = tracked(member, track);
 	return copy;
 }
 //#endregion
+//#region src/errors.ts
+function isDashError(error, ...codes) {
+	if (error instanceof HostError) return codes.length === 0 || codes.includes(error.code);
+	return false;
+}
+function errorMessage(error) {
+	if (error instanceof Error) return error.message;
+	if (typeof error === "string" && error) return error;
+	return "Something went wrong. Try again.";
+}
+async function unlessCancelled(call) {
+	try {
+		return await call;
+	} catch (error) {
+		if (isDashError(error, "cancelled")) return;
+		throw error;
+	}
+}
+//#endregion
+//#region src/latest.ts
+function latest() {
+	let running;
+	return (call) => {
+		running?.cancel();
+		running = call;
+		return call;
+	};
+}
+function debounce(milliseconds) {
+	const wait = latest();
+	return async (dash) => {
+		try {
+			await wait(dash.system.delay(milliseconds));
+			return true;
+		} catch (error) {
+			if (isDashError(error, "cancelled")) return false;
+			throw error;
+		}
+	};
+}
+//#endregion
 //#region src/index.ts
 const dash = {
 	ui: ui_exports,
 	system: system_exports,
 	network: network_exports,
-	file: file_exports
+	storage: storage_exports,
+	media: media_exports,
+	contacts: contacts_exports,
+	dot: dot_exports,
+	account: account_exports,
+	payments: payments_exports,
+	crypto: crypto_exports,
+	utils: utils_exports,
+	supports
 };
 //#endregion
-export { HostError, dash, tracked };
+export { DASH_API_SINCE, DASH_API_VERSION, DashError, dash, debounce, errorMessage, isDashError, latest, tracked, unlessCancelled, useHostDashApiVersions, warnAboveDashApiVersion };
 
 //# sourceMappingURL=index.js.map