dineway 0.1.49 → 0.2.1

package/dist/{transport-LSdZVXHF.mjs → portable-text-BASHceim.mjs}

@@ -282,137 +282,4 @@ function convertDataForWrite(data, fields) {
 }
 
 //#endregion
-//#region src/client/transport.ts
-/**
-* Transport layer for the Dineway client.
-*
-* Implements a composable interceptor pipeline that modifies requests
-* and responses. The client calls `transport.fetch(request)` — everything
-* else (auth, CSRF, retry) is handled by interceptors.
-*/
-const COOKIE_NAME_VALUE_PATTERN = /^([^;]+)/;
-function baseFetch(request) {
-	return globalThis.fetch(request);
-}
-/**
-* Creates a fetch function that runs requests through an interceptor pipeline.
-*/
-function createTransport(options = {}) {
-	const interceptors = options.interceptors ?? [];
-	let chain = baseFetch;
-	for (let i = interceptors.length - 1; i >= 0; i--) {
-		const interceptor = interceptors[i];
-		const next = chain;
-		chain = (req) => interceptor(req, next);
-	}
-	return { fetch: chain };
-}
-/**
-* Adds X-Dineway-Request: 1 and Origin headers to mutation requests
-* (POST, PUT, DELETE). The custom header satisfies Dineway's CSRF check;
-* the Origin header satisfies Astro's built-in origin verification which
-* rejects server-side POST requests that lack a matching Origin.
-*/
-function csrfInterceptor() {
-	const MUTATION_METHODS = new Set([
-		"POST",
-		"PUT",
-		"DELETE",
-		"PATCH"
-	]);
-	return (request, next) => {
-		if (MUTATION_METHODS.has(request.method)) {
-			const headers = new Headers(request.headers);
-			headers.set("X-Dineway-Request", "1");
-			if (!headers.has("Origin")) {
-				const url = new URL(request.url);
-				headers.set("Origin", url.origin);
-			}
-			return next(new Request(request, { headers }));
-		}
-		return next(request);
-	};
-}
-/**
-* Adds Authorization: Bearer header from a static token.
-*/
-function tokenInterceptor(token) {
-	return (request, next) => {
-		const headers = new Headers(request.headers);
-		headers.set("Authorization", `Bearer ${token}`);
-		return next(new Request(request, { headers }));
-	};
-}
-/**
-* Dev bypass interceptor. Calls the dev-bypass endpoint on first request
-* to establish a session, then forwards the session cookie on subsequent
-* requests.
-*/
-function devBypassInterceptor(baseUrl) {
-	let sessionCookie = null;
-	let initializing = null;
-	async function init() {
-		const bypassUrl = new URL("/_dineway/api/auth/dev-bypass", baseUrl);
-		const res = await globalThis.fetch(bypassUrl, { redirect: "manual" });
-		const setCookie = res.headers.get("set-cookie");
-		if (setCookie) {
-			const match = setCookie.match(COOKIE_NAME_VALUE_PATTERN);
-			if (match) sessionCookie = match[1];
-		}
-		if (res.body) await res.text().catch(() => {});
-	}
-	return async (request, next) => {
-		if (!sessionCookie) {
-			if (!initializing) initializing = init();
-			await initializing;
-		}
-		if (sessionCookie) {
-			const headers = new Headers(request.headers);
-			const existing = headers.get("cookie");
-			headers.set("cookie", existing ? `${existing}; ${sessionCookie}` : sessionCookie);
-			return next(new Request(request, { headers }));
-		}
-		return next(request);
-	};
-}
-/**
-* Auto-refreshes expired OAuth tokens on 401 responses.
-* Requires a refresh token and the token endpoint URL.
-*/
-function refreshInterceptor(options) {
-	let refreshing = null;
-	async function refresh() {
-		const res = await globalThis.fetch(options.tokenEndpoint, {
-			method: "POST",
-			headers: { "Content-Type": "application/json" },
-			body: JSON.stringify({
-				grant_type: "refresh_token",
-				refresh_token: options.refreshToken
-			})
-		});
-		if (!res.ok) return null;
-		const json = await res.json();
-		const tokenData = json.data && typeof json.data === "object" && "access_token" in json.data ? json.data : json;
-		const expiresAt = tokenData.expires_in ? new Date(Date.now() + tokenData.expires_in * 1e3).toISOString() : new Date(Date.now() + 36e5).toISOString();
-		if (options.onTokenRefreshed) options.onTokenRefreshed(tokenData.access_token, tokenData.refresh_token ?? options.refreshToken, expiresAt);
-		return tokenData.access_token;
-	}
-	return async (request, next) => {
-		const response = await next(request);
-		if (response.status === 401) {
-			if (!refreshing) refreshing = refresh().finally(() => {
-				refreshing = null;
-			});
-			const newToken = await refreshing;
-			if (newToken) {
-				const headers = new Headers(request.headers);
-				headers.set("Authorization", `Bearer ${newToken}`);
-				return next(new Request(request, { headers }));
-			}
-		}
-		return response;
-	};
-}
-
-//#endregion
-export { tokenInterceptor as a, markdownToPortableText as c, refreshInterceptor as i, portableTextToMarkdown as l, csrfInterceptor as n, convertDataForRead as o, devBypassInterceptor as r, convertDataForWrite as s, createTransport as t };
+export { portableTextToMarkdown as i, convertDataForWrite as n, markdownToPortableText as r, convertDataForRead as t };

package/dist/portable-text-E79LyjGo.d.mts

@@ -0,0 +1,45 @@
+//#region src/client/portable-text.d.ts
+/**
+ * Portable Text <-> Markdown conversion layer.
+ *
+ * Three tiers of block handling:
+ *   Tier 1: Standard PT blocks <-> standard Markdown (headings, paragraphs, lists, etc.)
+ *   Tier 2: Dineway custom blocks <-> Markdown directives (future)
+ *   Tier 3: Unknown blocks <-> opaque HTML comment fences (preserved, not editable)
+ */
+/** Minimal Portable Text block shape */
+interface PortableTextBlock {
+  _type: string;
+  _key?: string;
+  style?: string;
+  level?: number;
+  listItem?: string;
+  markDefs?: MarkDef[];
+  children?: PortableTextSpan[];
+  [key: string]: unknown;
+}
+interface PortableTextSpan {
+  _type: string;
+  _key?: string;
+  text?: string;
+  marks?: string[];
+  [key: string]: unknown;
+}
+interface MarkDef {
+  _key: string;
+  _type: string;
+  href?: string;
+  [key: string]: unknown;
+}
+/**
+ * Convert Portable Text blocks to Markdown.
+ * Unknown block types are serialized as opaque fences.
+ */
+declare function portableTextToMarkdown(blocks: PortableTextBlock[]): string;
+/**
+ * Convert Markdown to Portable Text blocks.
+ * Opaque fences (<!--ec:block ... -->) are deserialized and spliced back in.
+ */
+declare function markdownToPortableText(markdown: string): PortableTextBlock[];
+//#endregion
+export { markdownToPortableText as n, portableTextToMarkdown as r, PortableTextBlock as t };

package/dist/{preview-C-3YTX2U.mjs → preview-BjedZm8G.mjs}

@@ -1,7 +1,7 @@
 import { n as loadBetterSqlite3, t as createDatabase } from "./connection-CiJWiWya.mjs";
 import { runWithContext } from "./request-context.mjs";
-import { a as verifyPreviewSignature, t as buildPreviewSignatureHeader } from "./sidecar-client-mJxwayYN.mjs";
-import { t as generatePreviewToken } from "./tokens-SLmgowfd.mjs";
+import { a as verifyPreviewSignature, t as buildPreviewSignatureHeader } from "./sidecar-client-Ctzfyyp-.mjs";
+import { t as generatePreviewToken } from "./tokens-BDQU29Vd.mjs";
 import { createHash } from "node:crypto";
 import { sql } from "kysely";
 import { ulid } from "ulidx";
@@ -667,7 +667,8 @@ function createFilePreviewMiddleware(config) {
 		try {
 			return await runWithContext({
 				editMode: false,
-				db: session.db
+				db: session.db,
+				dbIsIsolated: true
 			}, async () => {
 				return injectPreviewToolbar(await next(), {
 					generatedAt: snapshotGeneratedAt,

package/dist/process-cache-CCDgti7j.mjs

@@ -0,0 +1,106 @@
+//#region src/utils/init-lock.ts
+const DEFAULT_DEADLINE_MS = 15e3;
+const DEFAULT_POLL_MS = 50;
+const MAX_WAIT_HEADROOM_MS = 15e3;
+function sleep(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function createInitLock() {
+	return {
+		ownerStartedAt: null,
+		generation: 0
+	};
+}
+async function initWithLock(lock, getCached, init, options) {
+	const deadlineMs = options?.deadlineMs ?? DEFAULT_DEADLINE_MS;
+	const pollMs = options?.pollMs ?? DEFAULT_POLL_MS;
+	const maxWaitMs = options?.maxWaitMs ?? deadlineMs + MAX_WAIT_HEADROOM_MS;
+	const waitStart = Date.now();
+	for (;;) {
+		const cached = getCached();
+		if (cached !== null && cached !== void 0) return cached;
+		const ownerStartedAt = lock.ownerStartedAt;
+		if (ownerStartedAt === null || Date.now() - ownerStartedAt > deadlineMs) {
+			lock.generation += 1;
+			const claim = lock.generation;
+			lock.ownerStartedAt = Date.now();
+			try {
+				const isCurrentClaim = () => lock.generation === claim;
+				const initPromise = Promise.resolve().then(() => init(isCurrentClaim));
+				options?.anchor?.(initPromise.then(() => void 0, () => void 0));
+				return await initPromise;
+			} finally {
+				if (lock.generation === claim) lock.ownerStartedAt = null;
+			}
+		}
+		if (Date.now() - waitStart > maxWaitMs) throw new Error(`initWithLock: timed out after ${maxWaitMs}ms waiting for initialization`);
+		await sleep(pollMs);
+	}
+}
+
+//#endregion
+//#region src/utils/process-cache.ts
+/**
+* Process-lifetime async value cache with single-flight and stuck-owner recovery.
+*
+* Use this for "compute once per process, read on many requests" caches. It
+* stores resolved values, never shared in-flight promises. One caller owns the
+* fetch under `initWithLock`; other callers poll for the resolved value and can
+* reclaim a stale owner after a deadline.
+*/
+const PROCESS_CACHE_EMPTY = Symbol("dineway.process-cache.empty");
+const RECLAIM_HEADROOM_MS = 5e3;
+function createProcessCache() {
+	return {
+		value: PROCESS_CACHE_EMPTY,
+		hasValue: false,
+		version: 0,
+		valueVersion: -1,
+		lock: createInitLock()
+	};
+}
+function invalidateProcessCache(cache) {
+	cache.version++;
+	cache.hasValue = false;
+	cache.value = PROCESS_CACHE_EMPTY;
+	cache.valueVersion = -1;
+	cache.lock.ownerStartedAt = null;
+}
+function withTimeout(promise, ms) {
+	return new Promise((resolve, reject) => {
+		const timer = setTimeout(() => {
+			reject(/* @__PURE__ */ new Error(`processCachedAsync: owner fetch exceeded ${ms}ms`));
+		}, ms);
+		promise.then(resolve, reject).finally(() => {
+			clearTimeout(timer);
+		});
+	});
+}
+function processCachedAsync(cache, fetch, options = {}) {
+	const versionAtCall = cache.version;
+	const ownerTimeoutMs = options.ownerTimeoutMs !== void 0 && Number.isFinite(options.ownerTimeoutMs) && options.ownerTimeoutMs > 0 ? options.ownerTimeoutMs : void 0;
+	const deadlineMs = ownerTimeoutMs === void 0 ? options.deadlineMs : Math.max(options.deadlineMs ?? 0, ownerTimeoutMs + RECLAIM_HEADROOM_MS);
+	return initWithLock(cache.lock, () => {
+		const cachedValue = cache.value;
+		return cache.hasValue && cache.valueVersion === versionAtCall && cachedValue !== PROCESS_CACHE_EMPTY ? { value: cachedValue } : null;
+	}, (isCurrentClaim) => {
+		const real = (async () => {
+			const value = await fetch();
+			if (isCurrentClaim()) {
+				cache.value = value;
+				cache.hasValue = true;
+				cache.valueVersion = versionAtCall;
+			}
+			return { value };
+		})();
+		options.anchor?.(real.then(() => void 0, () => void 0));
+		return ownerTimeoutMs === void 0 ? real : withTimeout(real, ownerTimeoutMs);
+	}, {
+		deadlineMs,
+		pollMs: options.pollMs,
+		maxWaitMs: options.maxWaitMs
+	}).then((box) => box.value);
+}
+
+//#endregion
+export { initWithLock as a, createInitLock as i, invalidateProcessCache as n, processCachedAsync as r, createProcessCache as t };

package/dist/project-env-DKibmuP8.mjs

@@ -0,0 +1,95 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { readFile, writeFile } from "node:fs/promises";
+
+//#region src/cli/project-env.ts
+const DEFAULT_DINEWAY_URL = "http://localhost:4321";
+const ENV_KEY_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
+const LINE_SPLIT_PATTERN = /\r?\n/;
+const DINEWAY_LOCAL_STATE_GITIGNORE_COMMENT = "# Dineway local state";
+const DINEWAY_LOCAL_STATE_GITIGNORE_ENTRIES = [
+	".dineway/deploy.json",
+	".dineway/forgeway.json",
+	".dineway/types.ts",
+	".dineway/schema.json",
+	".dineway/uploads/"
+];
+const NEWLINE_PATTERN = /\r?\n/g;
+function parseDotenvValue(value) {
+	const trimmed = value.trim();
+	if (trimmed.startsWith("\"") && trimmed.endsWith("\"") || trimmed.startsWith("'") && trimmed.endsWith("'")) return trimmed.slice(1, -1);
+	return trimmed;
+}
+function parseDotenv(text) {
+	const env = {};
+	for (const line of text.split(LINE_SPLIT_PATTERN)) {
+		const trimmed = line.trim();
+		if (!trimmed || trimmed.startsWith("#")) continue;
+		const normalized = trimmed.startsWith("export ") ? trimmed.slice(7).trim() : trimmed;
+		const equalsIndex = normalized.indexOf("=");
+		if (equalsIndex <= 0) continue;
+		const key = normalized.slice(0, equalsIndex).trim();
+		if (!ENV_KEY_PATTERN.test(key)) continue;
+		env[key] = parseDotenvValue(normalized.slice(equalsIndex + 1));
+	}
+	return env;
+}
+function readProjectEnv(cwd = process.cwd()) {
+	const envPath = join(cwd, ".env");
+	if (!existsSync(envPath)) return {};
+	return parseDotenv(readFileSync(envPath, "utf-8"));
+}
+function getProjectEnvValue(name, cwd = process.cwd()) {
+	return process.env[name] ?? readProjectEnv(cwd)[name];
+}
+function resolveDinewayBaseUrl(url, cwd = process.cwd()) {
+	if (url && url !== DEFAULT_DINEWAY_URL) return url;
+	const projectEnv = readProjectEnv(cwd);
+	return process.env["DINEWAY_URL"] ?? process.env["DINEWAY_SITE_URL"] ?? projectEnv["DINEWAY_SITE_URL"] ?? projectEnv["DINEWAY_URL"] ?? url ?? DEFAULT_DINEWAY_URL;
+}
+function resolveDinewayToken(token, cwd = process.cwd()) {
+	return token ?? getProjectEnvValue("DINEWAY_TOKEN", cwd);
+}
+function formatEnvValue(value) {
+	return value.replace(NEWLINE_PATTERN, "");
+}
+async function upsertProjectEnv(cwd, values) {
+	const envPath = join(cwd, ".env");
+	const existing = await readFile(envPath, "utf-8").catch(() => "");
+	const lines = existing ? existing.split(LINE_SPLIT_PATTERN) : [];
+	const seen = /* @__PURE__ */ new Set();
+	const nextLines = lines.map((line) => {
+		const trimmed = line.trim();
+		const normalized = trimmed.startsWith("export ") ? trimmed.slice(7).trim() : trimmed;
+		const equalsIndex = normalized.indexOf("=");
+		if (equalsIndex <= 0) return line;
+		const key = normalized.slice(0, equalsIndex).trim();
+		const value = values[key];
+		if (!(key in values) || value === void 0) return line;
+		seen.add(key);
+		return `${key}=${formatEnvValue(value)}`;
+	});
+	for (const [key, value] of Object.entries(values)) {
+		if (value === void 0 || seen.has(key)) continue;
+		nextLines.push(`${key}=${formatEnvValue(value)}`);
+	}
+	await writeFile(envPath, `${nextLines.filter((line, index) => line || index < nextLines.length - 1).join("\n")}\n`, "utf-8");
+}
+async function ensureProjectGitignoreEntry(cwd, entry) {
+	const gitignorePath = join(cwd, ".gitignore");
+	const existing = await readFile(gitignorePath, "utf-8").catch(() => "");
+	if (existing.split(LINE_SPLIT_PATTERN).map((line) => line.trim()).includes(entry)) return;
+	await writeFile(gitignorePath, `${existing}${existing && !existing.endsWith("\n") ? "\n" : ""}${entry}\n`, "utf-8");
+}
+async function ensureProjectGitignoreDinewayLocalState(cwd) {
+	const gitignorePath = join(cwd, ".gitignore");
+	const existing = await readFile(gitignorePath, "utf-8").catch(() => "");
+	const lines = new Set(existing.split(LINE_SPLIT_PATTERN).map((line) => line.trim()));
+	const missingEntries = DINEWAY_LOCAL_STATE_GITIGNORE_ENTRIES.filter((entry) => !lines.has(entry));
+	if (missingEntries.length === 0) return;
+	const block = [DINEWAY_LOCAL_STATE_GITIGNORE_COMMENT, ...missingEntries].join("\n");
+	await writeFile(gitignorePath, `${existing}${existing.trim() ? existing.endsWith("\n") ? "\n" : "\n\n" : ""}${block}\n`, "utf-8");
+}
+
+//#endregion
+export { resolveDinewayBaseUrl as a, getProjectEnvValue as i, ensureProjectGitignoreDinewayLocalState as n, resolveDinewayToken as o, ensureProjectGitignoreEntry as r, upsertProjectEnv as s, DEFAULT_DINEWAY_URL as t };

package/dist/{provider-loader-9it4vd6L.d.mts → provider-loader-DC2JdWeO.d.mts}

@@ -1,4 +1,4 @@
-import { f as MediaProvider } from "./placeholder-CXfoCtCd.mjs";
+import { f as MediaProvider } from "./placeholder-DkWkXfDI.mjs";
 
 //#region src/media/provider-loader.d.ts
 /**

package/dist/{public-url-B4xV4rGa.d.mts → public-url-DQJCnYi9.d.mts}

@@ -1,4 +1,4 @@
-import { t as DinewayConfig } from "./runtime-C4-2lSFg.mjs";
+import { ro as DinewayConfig } from "./types-DwoUifGE.mjs";
 
 //#region src/api/public-url.d.ts
 /**