dineway 0.1.8 → 0.1.11

package/dist/runtime.d.mts

@@ -1,9 +1,13 @@
-import { f as MediaProvider } from "./placeholder--wOi4TbO.mjs";
-import "./types-DOrVigru.mjs";
-import { Gn as EntryFilter, Kn as dinewayLoader, Un as CollectionFilter, Wn as EntryData, qn as getDb } from "./index-yvc6E_17.mjs";
-import "./runner-CFI6B6J2.mjs";
-import "./types-Cj0KMIZV.mjs";
-import "./validate-IPf8n4Fj.mjs";
+import { $t as EntryFilter, Qt as EntryData, Zt as CollectionFilter, en as dinewayLoader, tn as getDb } from "./runtime-C4-7y7xK.mjs";
+import "./types-Du8jreyC.mjs";
+import "./types-DgfUZqcd.mjs";
+import "./types-D4XVOt01.mjs";
+import { f as MediaProvider } from "./placeholder-CHkLckzK.mjs";
+import "./runner-9eIQXuc2.mjs";
+import "./index-CkljPf5F.mjs";
+import "./bylines-HfUKum_j.mjs";
+import "./types-C982qI5I.mjs";
+import "./validate-JCZihRIa.mjs";
 
 //#region src/media/provider-loader.d.ts
 /**

package/dist/runtime.mjs

@@ -1,7 +1,7 @@
 import "./dialect-helpers-DhTzaUxP.mjs";
-import "./base64-F8-DUraK.mjs";
-import "./types-BawVha09.mjs";
-import { n as getDb, t as dinewayLoader } from "./loader-sMG4TZ-u.mjs";
+import "./base64-Cz-aU0X1.mjs";
+import "./types-Bs6lTBBW.mjs";
+import { n as dinewayLoader, r as getDb } from "./loader-PZnPxFLc.mjs";
 
 //#region src/media/provider-loader.ts
 let virtualMediaProviders;

package/dist/schema-BNpI53of.mjs

@@ -0,0 +1,40 @@
+import { t as __exportAll } from "./chunk-ClPoSABd.mjs";
+import { n as SchemaRegistry } from "./registry-C-_hxLqa.mjs";
+import { r as getDb } from "./loader-PZnPxFLc.mjs";
+import { n as requestCached } from "./request-cache-DHMRr2Lf.mjs";
+
+//#region src/schema/query.ts
+/**
+* Get collection metadata by slug.
+*
+* @example
+* ```ts
+* import { getCollectionInfo } from "dineway";
+*
+* const info = await getCollectionInfo("posts");
+* if (info?.commentsEnabled) {
+*   // render comment UI
+* }
+* ```
+*/
+async function getCollectionInfo(slug) {
+	return requestCached(`collection-info:${slug}`, async () => {
+		return getCollectionInfoWithDb(await getDb(), slug);
+	});
+}
+/**
+* Get collection metadata with an explicit db handle.
+*
+* @internal Use `getCollectionInfo()` in templates. This variant is for
+* routes that already have a database handle.
+*/
+async function getCollectionInfoWithDb(db, slug) {
+	return new SchemaRegistry(db).getCollection(slug);
+}
+
+//#endregion
+//#region src/schema/index.ts
+var schema_exports = /* @__PURE__ */ __exportAll({ SchemaRegistry: () => SchemaRegistry });
+
+//#endregion
+export { getCollectionInfo as n, schema_exports as t };

package/dist/search-DM6CVti3.mjs

@@ -0,0 +1,337 @@
+import { t as __exportAll } from "./chunk-ClPoSABd.mjs";
+import { t as validateIdentifier } from "./validate-VPnKoIzW.mjs";
+import { t as FTSManager } from "./fts-manager-B1pTNEG_.mjs";
+import { r as getDb } from "./loader-PZnPxFLc.mjs";
+import { sql } from "kysely";
+import { toPlainText } from "@portabletext/toolkit";
+
+//#region src/search/query.ts
+/** Pattern to split on whitespace for query term extraction */
+const WHITESPACE_SPLIT_PATTERN = /\s+/;
+const FTS_OPERATORS_PATTERN = /\b(AND|OR|NOT|NEAR)\b/i;
+const DOUBLE_QUOTE_PATTERN = /"/g;
+const SNIPPET_AMP_PATTERN = /&/g;
+const SNIPPET_LT_PATTERN = /</g;
+const SNIPPET_GT_PATTERN = />/g;
+const SNIPPET_QUOT_PATTERN = /"/g;
+const SNIPPET_APOS_PATTERN = /'/g;
+function searchResultDisplayColumn(searchableFields) {
+	return searchableFields.includes("title") ? "title" : "slug";
+}
+/**
+* Search across multiple collections
+*
+* Public API that auto-injects the database.
+*
+* @param query - Search query (FTS5 syntax supported)
+* @param options - Search options
+* @returns Search results with pagination
+*
+* @example
+* ```typescript
+* import { search } from "dineway";
+*
+* const results = await search("hello world", {
+*   collections: ["posts", "pages"],
+*   limit: 20
+* });
+* ```
+*/
+async function search(query, options = {}) {
+	return searchWithDb(await getDb(), query, options);
+}
+/**
+* Search across multiple collections (with explicit db)
+*
+* @internal Use `search()` in templates. This variant is for admin routes
+* that already have a database handle.
+*
+* @param db - Kysely database instance
+* @param query - Search query (FTS5 syntax supported)
+* @param options - Search options
+* @returns Search results with pagination
+*/
+async function searchWithDb(db, query, options = {}) {
+	const ftsManager = new FTSManager(db);
+	const limit = options.limit ?? 20;
+	const status = options.status ?? "published";
+	let collections = options.collections;
+	if (!collections || collections.length === 0) collections = await getSearchableCollections(db);
+	if (collections.length === 0) return { items: [] };
+	const allResults = [];
+	for (const collection of collections) {
+		const config = await ftsManager.getSearchConfig(collection);
+		if (!config?.enabled) continue;
+		const collectionResults = await searchSingleCollection(db, collection, query, {
+			status,
+			locale: options.locale,
+			limit: limit * 2
+		}, config.weights);
+		allResults.push(...collectionResults);
+	}
+	allResults.sort((a, b) => b.score - a.score);
+	return { items: allResults.slice(0, limit) };
+}
+/**
+* Search within a single collection
+*
+* @param db - Kysely database instance
+* @param collection - Collection slug
+* @param query - Search query (FTS5 syntax supported)
+* @param options - Search options
+* @returns Search results with pagination
+*
+* @example
+* ```typescript
+* const results = await searchCollection(db, "posts", "hello world", {
+*   limit: 10
+* });
+* ```
+*/
+async function searchCollection(db, collection, query, options = {}) {
+	const config = await new FTSManager(db).getSearchConfig(collection);
+	if (!config?.enabled) return { items: [] };
+	return { items: await searchSingleCollection(db, collection, query, options, config.weights) };
+}
+/**
+* Internal function to search a single collection
+*/
+async function searchSingleCollection(db, collection, query, options, weights) {
+	validateIdentifier(collection, "collection slug");
+	const ftsManager = new FTSManager(db);
+	const ftsTable = ftsManager.getFtsTableName(collection);
+	const contentTable = ftsManager.getContentTableName(collection);
+	const limit = options.limit ?? 20;
+	const status = options.status ?? "published";
+	const locale = options.locale;
+	if (!await ftsManager.ftsTableExists(collection)) return [];
+	const escapedQuery = escapeQuery(query);
+	if (!escapedQuery) return [];
+	const searchableFields = await ftsManager.getSearchableFields(collection);
+	const displayColumn = searchResultDisplayColumn(searchableFields);
+	const displayColumnSql = sql`c.${sql.ref(displayColumn)}`;
+	let bm25Args = "";
+	if (weights && searchableFields.length > 0) {
+		const weightValues = ["0", "0"];
+		for (const field of searchableFields) weightValues.push(String(weights[field] ?? 1));
+		bm25Args = weightValues.join(", ");
+	}
+	const bm25Expr = bm25Args ? `bm25("${ftsTable}", ${bm25Args})` : `bm25("${ftsTable}")`;
+	return (await sql`
+			SELECT
+				c.id,
+				c.slug,
+				c.locale,
+				${displayColumnSql} as title,
+				snippet("${sql.raw(ftsTable)}", 2, '<mark>', '</mark>', '...', 32) as snippet,
+				${sql.raw(bm25Expr)} as score
+		FROM "${sql.raw(ftsTable)}" f
+		JOIN "${sql.raw(contentTable)}" c ON f.id = c.id
+		WHERE "${sql.raw(ftsTable)}" MATCH ${escapedQuery}
+		AND c.status = ${status}
+		AND c.deleted_at IS NULL
+		${locale ? sql`AND c.locale = ${locale}` : sql``}
+		ORDER BY score
+		LIMIT ${limit}
+	`.execute(db)).rows.map((row) => ({
+		collection,
+		id: row.id,
+		slug: row.slug,
+		locale: row.locale,
+		title: row.title ?? void 0,
+		snippet: row.snippet === null ? void 0 : sanitizeSnippet(row.snippet),
+		score: Math.abs(row.score)
+	}));
+}
+function sanitizeSnippet(snippet) {
+	return snippet.replace(SNIPPET_AMP_PATTERN, "&amp;").replace(SNIPPET_LT_PATTERN, "&lt;").replace(SNIPPET_GT_PATTERN, "&gt;").replace(SNIPPET_QUOT_PATTERN, "&quot;").replace(SNIPPET_APOS_PATTERN, "&#39;").replaceAll("&lt;mark&gt;", "<mark>").replaceAll("&lt;/mark&gt;", "</mark>");
+}
+/**
+* Get search suggestions for autocomplete
+*
+* @param db - Kysely database instance
+* @param query - Partial search query
+* @param options - Suggestion options
+* @returns Array of suggestions
+*/
+async function getSuggestions(db, query, options = {}) {
+	const limit = options.limit ?? 5;
+	const locale = options.locale;
+	let collections = options.collections;
+	if (!collections || collections.length === 0) collections = await getSearchableCollections(db);
+	if (collections.length === 0) return [];
+	const suggestions = [];
+	for (const collection of collections) {
+		const ftsManager = new FTSManager(db);
+		if (!(await ftsManager.getSearchConfig(collection))?.enabled) continue;
+		validateIdentifier(collection, "collection slug");
+		const ftsTable = ftsManager.getFtsTableName(collection);
+		const contentTable = ftsManager.getContentTableName(collection);
+		const displayColumn = searchResultDisplayColumn(await ftsManager.getSearchableFields(collection));
+		const displayColumnSql = sql`c.${sql.ref(displayColumn)}`;
+		const prefixQuery = escapeQuery(query);
+		if (!prefixQuery) continue;
+		const results = await sql`
+			SELECT
+				c.id,
+				${displayColumnSql} as title
+			FROM "${sql.raw(ftsTable)}" f
+			JOIN "${sql.raw(contentTable)}" c ON f.id = c.id
+			WHERE "${sql.raw(ftsTable)}" MATCH ${prefixQuery}
+			AND c.status = 'published'
+			AND c.deleted_at IS NULL
+			AND ${displayColumnSql} IS NOT NULL
+			${locale ? sql`AND c.locale = ${locale}` : sql``}
+			ORDER BY bm25("${sql.raw(ftsTable)}")
+			LIMIT ${limit}
+		`.execute(db);
+		for (const row of results.rows) suggestions.push({
+			collection,
+			id: row.id,
+			title: row.title
+		});
+	}
+	return suggestions.slice(0, limit);
+}
+/**
+* Get search statistics for all collections
+*/
+async function getSearchStats(db) {
+	const ftsManager = new FTSManager(db);
+	const collections = await getSearchableCollections(db);
+	const stats = { collections: {} };
+	for (const collection of collections) {
+		const collectionStats = await ftsManager.getIndexStats(collection);
+		if (collectionStats) stats.collections[collection] = collectionStats;
+	}
+	return stats;
+}
+/**
+* Get list of collections with search enabled
+*/
+async function getSearchableCollections(db) {
+	return (await db.selectFrom("_dineway_collections").select(["slug", "search_config"]).execute()).filter((r) => {
+		if (!r.search_config) return false;
+		try {
+			return JSON.parse(r.search_config).enabled === true;
+		} catch {
+			return false;
+		}
+	}).map((r) => r.slug);
+}
+/**
+* Escape a query string for FTS5
+*
+* Handles special characters and prevents injection.
+*/
+function escapeQuery(query) {
+	if (!query || typeof query !== "string") return "";
+	query = query.trim();
+	if (query.length === 0) return "";
+	const escaped = query.replace(DOUBLE_QUOTE_PATTERN, "\"\"");
+	if (FTS_OPERATORS_PATTERN.test(query)) return escaped;
+	if (query.startsWith("\"") && query.endsWith("\"")) return query;
+	const terms = escaped.split(WHITESPACE_SPLIT_PATTERN).filter((t) => t.length > 0);
+	if (terms.length === 0) return "";
+	return terms.map((t) => `"${t}"*`).join(" ");
+}
+
+//#endregion
+//#region src/search/text-extraction.ts
+/**
+* Text Extraction
+*
+* Extracts plain text from Portable Text blocks for FTS indexing.
+* Uses @portabletext/toolkit as base with extensions for custom block types.
+*/
+/**
+* Validate that a value looks like a Portable Text block array.
+* Each element must have at least a `_type` string property.
+*/
+function isPortableTextArray(value) {
+	return value.every((item) => typeof item === "object" && item !== null && "_type" in item && typeof item._type === "string");
+}
+/**
+* Extract additional text from custom block types that toPlainText doesn't handle
+*/
+function extractCustomBlockText(block) {
+	if (block._type === "code" && "code" in block && typeof block.code === "string") return block.code;
+	if (block._type === "image") {
+		const parts = [];
+		if ("alt" in block && typeof block.alt === "string" && block.alt) parts.push(block.alt);
+		if ("caption" in block && typeof block.caption === "string" && block.caption) parts.push(block.caption);
+		return parts.join(" ");
+	}
+	return "";
+}
+/**
+* Extract plain text from Portable Text blocks
+*
+* Uses @portabletext/toolkit's toPlainText for standard blocks,
+* plus extracts text from custom block types (code, images with alt/caption).
+*
+* @param blocks - Array of Portable Text blocks (or a JSON string)
+* @returns Plain text content
+*
+* @example
+* ```typescript
+* const text = extractPlainText([
+*   {
+*     _type: "block",
+*     _key: "abc",
+*     children: [{ _type: "span", _key: "s1", text: "Hello World" }]
+*   }
+* ]);
+* // Returns: "Hello World"
+* ```
+*/
+function extractPlainText(blocks) {
+	if (!blocks) return "";
+	let parsedBlocks;
+	if (typeof blocks === "string") try {
+		parsedBlocks = JSON.parse(blocks);
+	} catch {
+		return blocks;
+	}
+	else parsedBlocks = blocks;
+	if (!Array.isArray(parsedBlocks)) return "";
+	return [toPlainText(parsedBlocks.map((b) => {
+		const obj = { _type: b._type };
+		for (const [key, val] of Object.entries(b)) obj[key] = val;
+		return obj;
+	})), ...parsedBlocks.map(extractCustomBlockText).filter((text) => text.length > 0)].filter((t) => t.length > 0).join("\n");
+}
+/**
+* Extract searchable text from a content entry
+*
+* Extracts text from specified fields, handling both plain text and Portable Text.
+*
+* @param entry - Content entry data
+* @param fields - Field names to extract text from
+* @returns Object mapping field names to extracted text
+*/
+function extractSearchableFields(entry, fields) {
+	const result = {};
+	for (const field of fields) {
+		const value = entry[field];
+		if (value === null || value === void 0) {
+			result[field] = "";
+			continue;
+		}
+		if (typeof value === "string") if (value.startsWith("[")) result[field] = extractPlainText(value);
+		else result[field] = value;
+		else if (Array.isArray(value)) if (isPortableTextArray(value)) result[field] = extractPlainText(value);
+		else result[field] = JSON.stringify(value);
+		else if (typeof value === "object") result[field] = JSON.stringify(value);
+		else if (typeof value === "number" || typeof value === "boolean") result[field] = `${value}`;
+		else result[field] = "";
+	}
+	return result;
+}
+
+//#endregion
+//#region src/search/index.ts
+var search_exports = /* @__PURE__ */ __exportAll({ searchWithDb: () => searchWithDb });
+
+//#endregion
+export { getSuggestions as a, searchWithDb as c, getSearchStats as i, extractPlainText as n, search as o, extractSearchableFields as r, searchCollection as s, search_exports as t };

package/dist/secrets-dI8zzTV7.mjs

@@ -0,0 +1,160 @@
+import { i as encodeBase64url, n as decodeBase64url } from "./base64-Cz-aU0X1.mjs";
+import { t as OptionsRepository } from "./options-z8VVg1Ll.mjs";
+
+//#region src/config/secrets.ts
+const ENCRYPTION_KEY_PREFIX = "dineway_enc_v1_";
+const IP_SALT_OPTION_KEY = "dineway:ip_salt";
+const PREVIEW_SECRET_OPTION_KEY = "dineway:preview_secret";
+const ENCRYPTION_KEY_BODY_LENGTH = 43;
+const GENERATED_SECRET_BYTES = 32;
+const BASE64URL_CHARSET_PATTERN = /^[A-Za-z0-9_-]+$/;
+const ENCRYPTION_KEY_PATTERN = new RegExp(`^${ENCRYPTION_KEY_PREFIX.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}[A-Za-z0-9_-]{${ENCRYPTION_KEY_BODY_LENGTH}}$`);
+const SECRETS_CACHE_KEY = Symbol.for("@dineway-ai/core/secrets-cache@1");
+var DinewaySecretsError = class extends Error {
+	name = "DinewaySecretsError";
+	constructor(message, code) {
+		super(message);
+		this.code = code;
+	}
+};
+async function parseEncryptionKeys(raw) {
+	if (!raw) return null;
+	const entries = raw.split(",").map((entry) => entry.trim()).filter((entry) => entry.length > 0);
+	if (entries.length === 0) return null;
+	const parsed = [];
+	const seenKids = /* @__PURE__ */ new Set();
+	for (const entry of entries) {
+		if (!ENCRYPTION_KEY_PATTERN.test(entry)) throw new DinewaySecretsError(`DINEWAY_ENCRYPTION_KEY entry is malformed. Generate one with \`dineway secrets generate\`.`, "INVALID_ENCRYPTION_KEY");
+		const body = entry.slice(15);
+		const key = decodeBase64urlStrict(body);
+		if (!key || key.length !== GENERATED_SECRET_BYTES || encodeBase64url(key) !== body) throw new DinewaySecretsError("DINEWAY_ENCRYPTION_KEY body must be canonical base64url for 32 bytes", "INVALID_ENCRYPTION_KEY");
+		const kid = await fingerprintKeyBytes(key);
+		if (seenKids.has(kid)) continue;
+		seenKids.add(kid);
+		parsed.push({
+			kid,
+			key,
+			raw: entry
+		});
+	}
+	return parsed;
+}
+async function fingerprintKey(raw) {
+	if (!ENCRYPTION_KEY_PATTERN.test(raw)) throw new DinewaySecretsError(`Key must match "${ENCRYPTION_KEY_PREFIX}" followed by ${ENCRYPTION_KEY_BODY_LENGTH} base64url chars`, "INVALID_ENCRYPTION_KEY");
+	const body = raw.slice(15);
+	const bytes = decodeBase64urlStrict(body);
+	if (!bytes || bytes.length !== GENERATED_SECRET_BYTES || encodeBase64url(bytes) !== body) throw new DinewaySecretsError(`Key body must decode to ${GENERATED_SECRET_BYTES} canonical base64url bytes`, "INVALID_ENCRYPTION_KEY");
+	return fingerprintKeyBytes(bytes);
+}
+function generateEncryptionKey() {
+	const bytes = new Uint8Array(GENERATED_SECRET_BYTES);
+	crypto.getRandomValues(bytes);
+	return `${ENCRYPTION_KEY_PREFIX}${encodeBase64url(bytes)}`;
+}
+async function resolveSecrets(options) {
+	const env = options.env ?? readDefaultEnv();
+	const repo = options._repo ?? new OptionsRepository(options.db);
+	const previewEnvOverride = pickFirstNonEmpty(env.DINEWAY_PREVIEW_SECRET, env.PREVIEW_SECRET);
+	const ipSaltEnvOverride = pickFirstNonEmpty(env.DINEWAY_IP_SALT, env.IP_SALT);
+	const [previewSecret, ipSalt] = await Promise.all([previewEnvOverride !== null ? Promise.resolve({
+		value: previewEnvOverride,
+		source: "env"
+	}) : ensureGeneratedOption(repo, PREVIEW_SECRET_OPTION_KEY), ipSaltEnvOverride !== null ? Promise.resolve({
+		value: ipSaltEnvOverride,
+		source: "env"
+	}) : ensureGeneratedOption(repo, IP_SALT_OPTION_KEY)]);
+	return {
+		previewSecret: previewSecret.value,
+		previewSecretSource: previewSecret.source,
+		ipSalt: ipSalt.value,
+		ipSaltSource: ipSalt.source
+	};
+}
+async function validateEncryptionKeyAtStartup(env) {
+	const resolved = env ?? readDefaultEnv();
+	try {
+		await parseEncryptionKeys(resolved.DINEWAY_ENCRYPTION_KEY);
+		return true;
+	} catch (error) {
+		if (error instanceof DinewaySecretsError) {
+			console.error(`[dineway] DINEWAY_ENCRYPTION_KEY is invalid: ${error.message} Generate a fresh key with \`dineway secrets generate\`.`);
+			return false;
+		}
+		throw error;
+	}
+}
+function getSecretsCache() {
+	const holder = globalThis;
+	let entry = holder[SECRETS_CACHE_KEY];
+	if (!entry) {
+		entry = { cache: /* @__PURE__ */ new WeakMap() };
+		holder[SECRETS_CACHE_KEY] = entry;
+	}
+	return entry.cache;
+}
+function resolveSecretsCached(db) {
+	const cache = getSecretsCache();
+	const cached = cache.get(db);
+	if (cached) return cached;
+	const promise = resolveSecrets({ db }).catch((error) => {
+		cache.delete(db);
+		throw error;
+	});
+	cache.set(db, promise);
+	return promise;
+}
+async function ensureGeneratedOption(repo, optionKey) {
+	const existing = await repo.get(optionKey);
+	if (typeof existing === "string" && existing.length > 0) return {
+		value: existing,
+		source: "db"
+	};
+	const generated = generateRandomSecret();
+	if (await repo.setIfAbsent(optionKey, generated)) return {
+		value: generated,
+		source: "db"
+	};
+	const winner = await repo.get(optionKey);
+	if (typeof winner !== "string" || winner.length === 0) throw new DinewaySecretsError(`Failed to persist generated secret for "${optionKey}"`, "SECRET_PERSIST_FAILED");
+	return {
+		value: winner,
+		source: "db"
+	};
+}
+function generateRandomSecret() {
+	const bytes = new Uint8Array(GENERATED_SECRET_BYTES);
+	crypto.getRandomValues(bytes);
+	return encodeBase64url(bytes);
+}
+function pickFirstNonEmpty(...values) {
+	for (const value of values) if (typeof value === "string" && value.length > 0) return value;
+	return null;
+}
+function decodeBase64urlStrict(input) {
+	if (!BASE64URL_CHARSET_PATTERN.test(input)) return null;
+	try {
+		return decodeBase64url(input);
+	} catch {
+		return null;
+	}
+}
+async function fingerprintKeyBytes(key) {
+	const input = new ArrayBuffer(key.byteLength);
+	new Uint8Array(input).set(key);
+	const digest = await crypto.subtle.digest("SHA-256", input);
+	return Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join("").slice(0, 8);
+}
+function readDefaultEnv() {
+	const meta = import.meta.env ?? {};
+	const proc = typeof process !== "undefined" && process.env ? process.env : {};
+	return {
+		DINEWAY_ENCRYPTION_KEY: meta.DINEWAY_ENCRYPTION_KEY ?? proc.DINEWAY_ENCRYPTION_KEY,
+		DINEWAY_PREVIEW_SECRET: meta.DINEWAY_PREVIEW_SECRET ?? proc.DINEWAY_PREVIEW_SECRET,
+		PREVIEW_SECRET: meta.PREVIEW_SECRET ?? proc.PREVIEW_SECRET,
+		DINEWAY_IP_SALT: meta.DINEWAY_IP_SALT ?? proc.DINEWAY_IP_SALT,
+		IP_SALT: meta.IP_SALT ?? proc.IP_SALT
+	};
+}
+
+//#endregion
+export { validateEncryptionKeyAtStartup as a, resolveSecretsCached as i, fingerprintKey as n, generateEncryptionKey as r, DinewaySecretsError as t };