@zenbujs/core 0.0.4 → 0.0.8

package/dist/renderer-host-BQpS0ZM2.mjs

@@ -1,2 +0,0 @@
-import "./renderer-host-ztaSIOGx.mjs";
-export {};

package/dist/rpc-D_s7-WZe.mjs

@@ -1,2 +0,0 @@
-import "./rpc-CsgWnlZx.mjs";
-export {};

package/dist/runtime-C95iyVn6.mjs

@@ -1,461 +0,0 @@
-//#region src/runtime.ts
-function optional(ref) {
-	return {
-		__optional: true,
-		ref
-	};
-}
-function resolveDep(entry) {
-	if (typeof entry === "string") return {
-		key: entry,
-		optional: false
-	};
-	if (typeof entry === "object" && entry !== null && "__optional" in entry) {
-		const ref = entry.ref;
-		return {
-			key: typeof ref === "string" ? ref : ref.key,
-			optional: true
-		};
-	}
-	return {
-		key: entry.key,
-		optional: false
-	};
-}
-var Service = class {
-	static key;
-	static deps;
-	ctx;
-	/** @internal */
-	__setupCleanups = /* @__PURE__ */ new Map();
-	evaluate() {}
-	setup(key, fn) {
-		const existing = this.__setupCleanups.get(key);
-		if (existing) try {
-			existing("reload");
-		} catch (e) {
-			console.error(`[hot] setup cleanup "${key}" failed:`, e);
-		}
-		const cleanup = fn();
-		if (cleanup) this.__setupCleanups.set(key, cleanup);
-		else this.__setupCleanups.delete(key);
-	}
-	/**
-	* Run `fn` and return its result. Historically reported a boot-trace span;
-	* now a thin wrapper preserved for caller ergonomics inside service
-	* `evaluate()` bodies.
-	*/
-	trace(_name, fn, _meta) {
-		return Promise.resolve(fn());
-	}
-	traceSync(_name, fn, _meta) {
-		return fn();
-	}
-	/** @internal */
-	async __cleanupAllSetups(reason = "shutdown") {
-		for (const [key, cleanup] of this.__setupCleanups) try {
-			await cleanup(reason);
-		} catch (e) {
-			console.error(`[hot] setup cleanup "${key}" failed:`, e);
-		}
-		this.__setupCleanups.clear();
-	}
-};
-/**
-* Declare a Service base class with typed deps. The returned class has
-* `static deps = <your map>` already set, and `this.ctx` is auto-typed
-* from the dep classes — no `declare ctx` needed in the subclass.
-*
-*     export class WindowService extends serviceWithDeps({
-*       baseWindow: BaseWindowService,
-*       http: HttpService,
-*     }) {
-*       static key = "window"
-*       evaluate() {
-*         this.ctx.baseWindow  // BaseWindowService
-*         this.ctx.http        // HttpService
-*       }
-*     }
-*
-* `optional(SomeService)` is supported and produces `Instance | undefined`.
-*/
-function serviceWithDeps(deps) {
-	class ServiceWithDeps extends Service {
-		static deps = deps;
-	}
-	return ServiceWithDeps;
-}
-const SERVICE_BASE_METHODS = new Set(Object.getOwnPropertyNames(Service.prototype));
-var ServiceRuntime = class {
-	definitions = /* @__PURE__ */ new Map();
-	dependentsIndex = /* @__PURE__ */ new Map();
-	dirtyKeys = /* @__PURE__ */ new Set();
-	drainError = null;
-	draining = null;
-	registrationTokens = /* @__PURE__ */ new Map();
-	slots = /* @__PURE__ */ new Map();
-	onReconciledCallbacks = [];
-	register(ServiceClass, importMeta) {
-		const hot = importMeta?.hot ?? null;
-		const baseKey = ServiceClass.key;
-		if (!baseKey) throw new Error("Service must have a static key property");
-		const slotKey = baseKey;
-		this.definitions.set(slotKey, ServiceClass);
-		const slot = this.slots.get(slotKey);
-		if (slot) slot.ServiceClass = ServiceClass;
-		else this.slots.set(slotKey, {
-			error: null,
-			instance: null,
-			ServiceClass,
-			status: "blocked"
-		});
-		this.rebuildDependentsIndex();
-		hot?.accept();
-		const token = Symbol(slotKey);
-		this.registrationTokens.set(slotKey, token);
-		hot?.prune?.(() => {
-			this.unregister(slotKey, token);
-		});
-		this.scheduleReconcile([slotKey]);
-	}
-	getAllKeys() {
-		return [...this.slots.keys()];
-	}
-	getSlot(key) {
-		return this.slots.get(key);
-	}
-	async whenIdle() {
-		while (this.draining) await this.draining;
-		if (this.drainError) {
-			const error = this.drainError;
-			this.drainError = null;
-			throw error;
-		}
-	}
-	async reloadAll() {
-		const keys = [...this.slots.keys()];
-		if (keys.length === 0) return;
-		await this.scheduleReconcile(keys);
-		await this.whenIdle();
-	}
-	async shutdown() {
-		try {
-			await this.whenIdle();
-		} catch (error) {
-			console.error("[hot] runtime idle wait failed during shutdown:", error);
-		}
-		const keys = [...this.slots.keys()].reverse();
-		for (const key of keys) await this.teardownService(key, { removeSlot: true });
-		this.definitions.clear();
-		this.dependentsIndex.clear();
-		this.dirtyKeys.clear();
-		this.registrationTokens.clear();
-	}
-	get(ref) {
-		const slot = this.slots.get(ref.key);
-		if (!slot || slot.status !== "ready" || !slot.instance) throw new Error(`Service "${ref.key}" not ready. Is it registered and evaluated?`);
-		return slot.instance;
-	}
-	buildRouter() {
-		const router = {};
-		for (const [slotKey, slot] of this.slots) {
-			if (slot.status !== "ready" || !slot.instance) continue;
-			const proto = Object.getPrototypeOf(slot.instance);
-			const methods = {};
-			for (const name of Object.getOwnPropertyNames(proto)) {
-				if (SERVICE_BASE_METHODS.has(name)) continue;
-				if (name.startsWith("_")) continue;
-				const desc = Object.getOwnPropertyDescriptor(proto, name);
-				if (!desc || typeof desc.value !== "function") continue;
-				const instance = slot.instance;
-				methods[name] = (...args) => instance[name](...args);
-			}
-			if (Object.keys(methods).length > 0) router[slotKey] = methods;
-		}
-		return router;
-	}
-	onReconciled(cb) {
-		this.onReconciledCallbacks.push(cb);
-		return () => {
-			const idx = this.onReconciledCallbacks.indexOf(cb);
-			if (idx >= 0) this.onReconciledCallbacks.splice(idx, 1);
-		};
-	}
-	resolveDepSlot(depKey) {
-		return this.slots.get(depKey);
-	}
-	injectCtx(instance, ServiceClass) {
-		const deps = ServiceClass.deps ?? {};
-		const ctx = {};
-		for (const [name, entry] of Object.entries(deps)) {
-			const { key, optional: isOptional } = resolveDep(entry);
-			const slot = this.resolveDepSlot(key);
-			if (!slot || slot.status !== "ready" || !slot.instance) {
-				if (isOptional) {
-					ctx[name] = void 0;
-					continue;
-				}
-				throw new Error(`Dependency "${key}" not ready for "${ServiceClass.key}"`);
-			}
-			ctx[name] = slot.instance;
-		}
-		instance.ctx = ctx;
-	}
-	rebuildDependentsIndex() {
-		const next = /* @__PURE__ */ new Map();
-		for (const [slotKey, ServiceClass] of this.definitions) {
-			const deps = ServiceClass.deps ?? {};
-			for (const entry of Object.values(deps)) {
-				const { key: depKey } = resolveDep(entry);
-				const dependents = next.get(depKey) ?? /* @__PURE__ */ new Set();
-				dependents.add(slotKey);
-				next.set(depKey, dependents);
-			}
-		}
-		this.dependentsIndex = next;
-	}
-	getAffectedKeys(changedKeys) {
-		const affected = /* @__PURE__ */ new Set();
-		const visit = (key) => {
-			if (affected.has(key)) return;
-			affected.add(key);
-			for (const dependent of this.dependentsIndex.get(key) ?? []) visit(dependent);
-		};
-		for (const key of changedKeys) visit(key);
-		return [...affected].filter((key) => this.definitions.has(key));
-	}
-	listMissingDeps(ServiceClass) {
-		const deps = ServiceClass.deps ?? {};
-		const missing = [];
-		for (const entry of Object.values(deps)) {
-			const { key, optional: isOptional } = resolveDep(entry);
-			if (isOptional) continue;
-			const slot = this.resolveDepSlot(key);
-			if (!slot || slot.status !== "ready" || !slot.instance) missing.push(key);
-		}
-		return missing;
-	}
-	ensureSlot(key, ServiceClass) {
-		const existing = this.slots.get(key);
-		if (existing) return existing;
-		const slot = {
-			error: null,
-			instance: null,
-			ServiceClass,
-			status: "blocked"
-		};
-		this.slots.set(key, slot);
-		return slot;
-	}
-	async teardownService(key, options = {}) {
-		const slot = this.slots.get(key);
-		if (!slot) return;
-		const instance = slot.instance;
-		slot.instance = null;
-		slot.status = "blocked";
-		slot.error = null;
-		if (instance) await instance.__cleanupAllSetups(options.reason ?? "shutdown");
-		if (options.removeSlot) this.slots.delete(key);
-	}
-	async unregister(key, token) {
-		if (this.registrationTokens.get(key) !== token) return;
-		this.registrationTokens.delete(key);
-		this.definitions.delete(key);
-		await this.teardownService(key, { removeSlot: true });
-		this.rebuildDependentsIndex();
-		await this.scheduleReconcile([key]);
-	}
-	async scheduleReconcile(keys) {
-		for (const key of keys) this.dirtyKeys.add(key);
-		if (this.draining) return this.draining;
-		this.draining = (async () => {
-			try {
-				while (this.dirtyKeys.size > 0) {
-					const batch = [...this.dirtyKeys];
-					this.dirtyKeys.clear();
-					await this.reconcileBatch(batch);
-				}
-			} catch (error) {
-				this.drainError = error;
-				console.error("[hot] runtime reconcile failed:", error);
-			} finally {
-				this.draining = null;
-				if (this.dirtyKeys.size > 0) this.scheduleReconcile([]);
-			}
-		})();
-		return this.draining;
-	}
-	async reconcileBatch(changedKeys) {
-		const affectedKeys = this.getAffectedKeys(changedKeys);
-		if (affectedKeys.length === 0) return;
-		const affected = /* @__PURE__ */ new Map();
-		for (const key of affectedKeys) {
-			const ServiceClass = this.definitions.get(key);
-			if (ServiceClass) affected.set(key, ServiceClass);
-		}
-		const levels = this.topologicalLevels(affected);
-		for (const level of [...levels].reverse()) await Promise.all(level.map(async (key) => {
-			const slot = this.slots.get(key);
-			if (slot?.instance) await slot.instance.__cleanupAllSetups("reload");
-		}));
-		for (const level of levels) await Promise.all(level.map((key) => this.reconcileKey(key)));
-		if (affectedKeys.length > 0) for (const cb of this.onReconciledCallbacks) try {
-			cb(affectedKeys);
-		} catch (e) {
-			console.error("[hot] onReconciled callback failed:", e);
-		}
-	}
-	async reconcileKey(key) {
-		const ServiceClass = this.definitions.get(key);
-		if (!ServiceClass) return;
-		const slot = this.ensureSlot(key, ServiceClass);
-		slot.ServiceClass = ServiceClass;
-		const missingDeps = this.listMissingDeps(ServiceClass);
-		if (missingDeps.length > 0) {
-			const shouldLog = slot.instance !== null || slot.status !== "blocked";
-			await this.teardownService(key, { reason: "reload" });
-			if (shouldLog) console.log(`[hot] ${key} waiting on: ${missingDeps.join(", ")}`);
-			return;
-		}
-		let instance = slot.instance;
-		if (!instance) {
-			instance = new ServiceClass();
-			slot.instance = instance;
-		} else Object.setPrototypeOf(instance, ServiceClass.prototype);
-		slot.status = "evaluating";
-		slot.error = null;
-		try {
-			await instance.__cleanupAllSetups("reload");
-			this.injectCtx(instance, ServiceClass);
-			await instance.evaluate();
-			slot.status = "ready";
-		} catch (e) {
-			slot.status = "failed";
-			slot.error = e;
-			console.error(`[hot] ${key} failed to evaluate:`, e);
-		}
-	}
-	topologicalLevels(services) {
-		const keys = new Set(services.keys());
-		const inDegree = /* @__PURE__ */ new Map();
-		const dependents = /* @__PURE__ */ new Map();
-		for (const key of keys) {
-			inDegree.set(key, 0);
-			dependents.set(key, []);
-		}
-		for (const [slotKey, ServiceClass] of services) {
-			const deps = ServiceClass.deps ?? {};
-			let degree = 0;
-			for (const entry of Object.values(deps)) {
-				const { key: depKey, optional: isOptional } = resolveDep(entry);
-				if (keys.has(depKey)) {
-					degree++;
-					dependents.get(depKey).push(slotKey);
-				} else if (isOptional) continue;
-			}
-			inDegree.set(slotKey, degree);
-		}
-		const levels = [];
-		let queue = [...keys].filter((k) => inDegree.get(k) === 0);
-		while (queue.length > 0) {
-			levels.push(queue);
-			const next = [];
-			for (const key of queue) for (const dep of dependents.get(key)) {
-				const d = inDegree.get(dep) - 1;
-				inDegree.set(dep, d);
-				if (d === 0) next.push(dep);
-			}
-			queue = next;
-		}
-		const resolved = levels.flat();
-		if (resolved.length !== keys.size) {
-			const missing = [...keys].filter((k) => !resolved.includes(k));
-			throw new Error(`Circular dependency detected involving: ${missing.join(", ")}`);
-		}
-		return levels;
-	}
-};
-/**
-* fixme: i don't think these commments make sense
-*/
-/**
-* Devtools-only handles, attached to the global so they aren't part of the
-* public `ServiceRuntime` autocomplete surface. Same shape React DevTools
-* uses (`__REACT_DEVTOOLS_GLOBAL_HOOK__`): user code reading
-* `runtime.<...>` never lands on these methods; you only find them if you
-* specifically type `globalThis.__zenbu_dev__`. Kept here (next to the
-* runtime that owns the state) because the hook reaches into private
-* implementation details — `scheduleReconcile` stays `private` on the
-* class; the cast lives inside the encapsulation boundary.
-*/
-function installDevHook(rt) {
-	const internals = rt;
-	globalThis.__zenbu_dev__ = { reloadService: async (key) => {
-		if (!internals.definitions.has(key)) throw new Error(`No service registered for key "${key}"`);
-		await internals.scheduleReconcile([key]);
-		await rt.whenIdle();
-	} };
-}
-const runtime = (() => {
-	const existing = globalThis.__zenbu_service_runtime__;
-	if (existing) {
-		Object.setPrototypeOf(existing, ServiceRuntime.prototype);
-		installDevHook(existing);
-		return existing;
-	}
-	const fresh = new ServiceRuntime();
-	globalThis.__zenbu_service_runtime__ = fresh;
-	installDevHook(fresh);
-	return fresh;
-})();
-function getPluginRegistry() {
-	const slot = globalThis;
-	if (!slot.__zenbu_plugin_registry__) slot.__zenbu_plugin_registry__ = {
-		plugins: /* @__PURE__ */ new Map(),
-		appEntrypoint: null
-	};
-	return slot.__zenbu_plugin_registry__;
-}
-/**
-* Register a plugin's resolved manifest. Idempotent — replaces any existing
-* entry for the same `name`. Called by the loader-emitted barrel; user code
-* normally does not call this directly.
-*/
-function registerPlugin(record) {
-	getPluginRegistry().plugins.set(record.name, record);
-}
-/**
-* Drop a plugin from the registry. Used when the loader regenerates the
-* barrel and needs to clear stale entries.
-*/
-function unregisterPlugin(name) {
-	getPluginRegistry().plugins.delete(name);
-}
-/**
-* Replace the entire plugin set in one shot. The loader uses this on every
-* barrel regeneration so removed plugins disappear cleanly.
-*/
-function replacePlugins(records) {
-	const reg = getPluginRegistry();
-	reg.plugins.clear();
-	for (const record of records) reg.plugins.set(record.name, record);
-}
-function getPlugins() {
-	return [...getPluginRegistry().plugins.values()];
-}
-function getPlugin(name) {
-	return getPluginRegistry().plugins.get(name);
-}
-/**
-* Set the boot-window HTML path. Called once by the loader-emitted barrel.
-* Consumers (`view-registry`, `vite-plugins`) ask for it via
-* `getAppEntrypoint()`.
-*/
-function registerAppEntrypoint(htmlPath) {
-	getPluginRegistry().appEntrypoint = htmlPath;
-}
-function getAppEntrypoint() {
-	return getPluginRegistry().appEntrypoint;
-}
-//#endregion
-export { getPlugins as a, registerPlugin as c, serviceWithDeps as d, unregisterPlugin as f, getPlugin as i, replacePlugins as l, ServiceRuntime as n, optional as o, getAppEntrypoint as r, registerAppEntrypoint as s, Service as t, runtime as u };

package/dist/runtime-CsiDppGF.d.mts

@@ -1,149 +0,0 @@
-//#region src/runtime.d.ts
-type CleanupReason = "reload" | "shutdown";
-type SetupCleanup = ((reason: CleanupReason) => void | Promise<void>) | void;
-type SetupFn = () => SetupCleanup;
-interface ServiceSlot {
-  error: unknown | null;
-  instance: Service | null;
-  ServiceClass: typeof Service;
-  status: "blocked" | "evaluating" | "ready" | "failed";
-}
-type AnyServiceClass = abstract new (...args: any[]) => Service;
-type DepRef = AnyServiceClass | string;
-type OptionalDep<R extends DepRef = DepRef> = {
-  __optional: true;
-  ref: R;
-};
-type DepEntry = DepRef | OptionalDep;
-type DepInstance<D> = D extends OptionalDep<infer R> ? R extends AnyServiceClass ? InstanceType<R> | undefined : unknown : D extends AnyServiceClass ? InstanceType<D> : unknown;
-type ResolveCtx<TDeps> = { [K in keyof TDeps]: DepInstance<TDeps[K]> };
-declare function optional<R extends DepRef>(ref: R): OptionalDep<R>;
-declare abstract class Service {
-  static key: string;
-  static deps: Record<string, DepEntry>;
-  ctx: any;
-  /** @internal */
-  __setupCleanups: Map<string, (reason: CleanupReason) => void | Promise<void>>;
-  evaluate(): void | Promise<void>;
-  setup(key: string, fn: SetupFn): void;
-  /**
-   * Run `fn` and return its result. Historically reported a boot-trace span;
-   * now a thin wrapper preserved for caller ergonomics inside service
-   * `evaluate()` bodies.
-   */
-  trace<T>(_name: string, fn: () => T | Promise<T>, _meta?: Record<string, unknown>): Promise<T>;
-  traceSync<T>(_name: string, fn: () => T, _meta?: Record<string, unknown>): T;
-  /** @internal */
-  __cleanupAllSetups(reason?: CleanupReason): Promise<void>;
-}
-/**
- * Declare a Service base class with typed deps. The returned class has
- * `static deps = <your map>` already set, and `this.ctx` is auto-typed
- * from the dep classes — no `declare ctx` needed in the subclass.
- *
- *     export class WindowService extends serviceWithDeps({
- *       baseWindow: BaseWindowService,
- *       http: HttpService,
- *     }) {
- *       static key = "window"
- *       evaluate() {
- *         this.ctx.baseWindow  // BaseWindowService
- *         this.ctx.http        // HttpService
- *       }
- *     }
- *
- * `optional(SomeService)` is supported and produces `Instance | undefined`.
- */
-declare function serviceWithDeps<TDeps extends Record<string, DepEntry>>(deps: TDeps): (abstract new () => {
-  ctx: ResolveCtx<TDeps>; /** @internal */
-  __setupCleanups: Map<string, (reason: CleanupReason) => void | Promise<void>>;
-  evaluate(): void | Promise<void>;
-  setup(key: string, fn: SetupFn): void;
-  /**
-   * Run `fn` and return its result. Historically reported a boot-trace span;
-   * now a thin wrapper preserved for caller ergonomics inside service
-   * `evaluate()` bodies.
-   */
-  trace<T>(_name: string, fn: () => T | Promise<T>, _meta?: Record<string, unknown>): Promise<T>;
-  traceSync<T>(_name: string, fn: () => T, _meta?: Record<string, unknown>): T; /** @internal */
-  __cleanupAllSetups(reason?: CleanupReason): Promise<void>;
-}) & {
-  deps: Record<string, DepEntry>;
-  key: string;
-};
-declare class ServiceRuntime {
-  private definitions;
-  private dependentsIndex;
-  private dirtyKeys;
-  private drainError;
-  private draining;
-  private registrationTokens;
-  private slots;
-  private onReconciledCallbacks;
-  register(ServiceClass: typeof Service, importMeta?: ImportMeta | null): void;
-  getAllKeys(): string[];
-  getSlot(key: string): ServiceSlot | undefined;
-  whenIdle(): Promise<void>;
-  reloadAll(): Promise<void>;
-  shutdown(): Promise<void>;
-  get<T extends Service>(ref: {
-    key: string;
-  }): T;
-  buildRouter(): Record<string, Record<string, (...args: any[]) => any>>;
-  onReconciled(cb: (changedKeys: string[]) => void): () => void;
-  private resolveDepSlot;
-  private injectCtx;
-  private rebuildDependentsIndex;
-  private getAffectedKeys;
-  private listMissingDeps;
-  private ensureSlot;
-  private teardownService;
-  private unregister;
-  private scheduleReconcile;
-  private reconcileBatch;
-  private reconcileKey;
-  private topologicalLevels;
-}
-declare const runtime: ServiceRuntime;
-/**
- * A plugin manifest after the loader has resolved every relative path to
- * absolute. Mirrors `ResolvedPlugin` in `cli/lib/build-config.ts` but is
- * declared inline here to avoid runtime.ts importing CLI code.
- */
-interface PluginRecord {
-  name: string;
-  dir: string;
-  services: string[];
-  schemaPath?: string;
-  migrationsPath?: string;
-  preloadPath?: string;
-  eventsPath?: string;
-  icons?: Record<string, string>;
-}
-/**
- * Register a plugin's resolved manifest. Idempotent — replaces any existing
- * entry for the same `name`. Called by the loader-emitted barrel; user code
- * normally does not call this directly.
- */
-declare function registerPlugin(record: PluginRecord): void;
-/**
- * Drop a plugin from the registry. Used when the loader regenerates the
- * barrel and needs to clear stale entries.
- */
-declare function unregisterPlugin(name: string): void;
-/**
- * Replace the entire plugin set in one shot. The loader uses this on every
- * barrel regeneration so removed plugins disappear cleanly.
- */
-declare function replacePlugins(records: PluginRecord[]): void;
-declare function getPlugins(): PluginRecord[];
-declare function getPlugin(name: string): PluginRecord | undefined;
-/**
- * Set the boot-window HTML path. Called once by the loader-emitted barrel.
- * Consumers (`view-registry`, `vite-plugins`) ask for it via
- * `getAppEntrypoint()`.
- */
-declare function registerAppEntrypoint(htmlPath: string): void;
-declare function getAppEntrypoint(): string | null;
-//#endregion
-export { getAppEntrypoint as a, optional as c, replacePlugins as d, runtime as f, ServiceRuntime as i, registerAppEntrypoint as l, unregisterPlugin as m, PluginRecord as n, getPlugin as o, serviceWithDeps as p, Service as r, getPlugins as s, CleanupReason as t, registerPlugin as u };

package/dist/schema-dGK6qkfR.mjs

@@ -1,28 +0,0 @@
-import { a as f, i as createSchema } from "./schema-CIg4GzHQ.mjs";
-import zod from "zod";
-//#region src/schema.ts
-const viewRegistryEntrySchema = zod.object({
-	scope: zod.string(),
-	url: zod.string(),
-	port: zod.number(),
-	icon: zod.string().optional(),
-	meta: zod.object({
-		kind: zod.string().optional(),
-		sidebar: zod.boolean().optional(),
-		bottomPanel: zod.boolean().optional(),
-		label: zod.string().optional()
-	}).optional()
-});
-const windowBoundsSchema = zod.object({
-	x: zod.number(),
-	y: zod.number(),
-	width: zod.number(),
-	height: zod.number()
-});
-const windowPrefsSchema = zod.object({ lastKnownBounds: windowBoundsSchema.optional() });
-const schema = createSchema({
-	lastKnownViewRegistry: f.array(viewRegistryEntrySchema).default([]),
-	windowPrefs: f.record(zod.string(), windowPrefsSchema).default({})
-});
-//#endregion
-export { schema as t };

package/dist/server-CgzQOPSW.mjs

@@ -1,2 +0,0 @@
-import "./server-DB3Eki_G.mjs";
-export {};