@hasna/shortlinks 0.1.23 → 0.2.0

package/dist/client-store.d.ts

@@ -0,0 +1,47 @@
+import { CloudShortlinksStore } from "./cloud-store.js";
+import type { Env } from "@hasna/contracts/mode";
+import type { ListLinksOptions, Store, TotalStats } from "./store-interface.js";
+import type { AddDomainInput, Click, ClickInput, CreateLinkInput, Domain, Link, LinkStats } from "./types.js";
+/** The self_hosted/cloud HTTP transport. Same client code for both tiers. */
+export { CloudShortlinksStore as ApiStore } from "./cloud-store.js";
+export type { Store } from "./store-interface.js";
+/**
+ * On-box SQLite store. An async adapter over the synchronous sqlite engine
+ * (`ShortlinksStore`) so it satisfies the shared async {@link Store} interface.
+ */
+export declare class LocalStore implements Store {
+    readonly kind: "local";
+    private readonly inner;
+    constructor(dbPath?: string);
+    addDomain(input: AddDomainInput): Promise<Domain>;
+    listDomains(): Promise<Domain[]>;
+    getDomain(hostnameOrId: string): Promise<Domain | null>;
+    getDefaultDomain(): Promise<Domain | null>;
+    createLink(input: CreateLinkInput): Promise<Link>;
+    listLinks(options?: ListLinksOptions): Promise<Link[]>;
+    getLink(domainOrSlug: string, maybeSlug?: string): Promise<Link | null>;
+    resolve(hostname: string, slug: string): Promise<Link | null>;
+    setLinkActive(domainOrSlug: string, slugOrActive: string | boolean, active?: boolean): Promise<Link>;
+    deleteLink(domainOrSlug: string, maybeSlug?: string): Promise<Link>;
+    recordClick(link: Link, input?: ClickInput): Promise<Click>;
+    getStats(domainOrSlug: string, maybeSlug?: string): Promise<LinkStats>;
+    totalStats(): Promise<TotalStats>;
+    close(): Promise<void>;
+}
+export interface ResolveStoreOptions {
+    /** Explicit local SQLite path (CLI `--db`); ignored in cloud mode. */
+    dbPath?: string;
+    /** Transport overrides for the cloud client (test injection: fetchImpl, ...). */
+    cloudOverrides?: Parameters<typeof CloudShortlinksStore.fromEnv>[1];
+}
+/**
+ * Resolve the active {@link Store} for the current environment. Returns the
+ * cloud {@link ApiStore} when the client flip is on, otherwise a
+ * {@link LocalStore}. Throws when cloud was requested but is misconfigured.
+ */
+export declare function resolveStore(env?: Env, options?: ResolveStoreOptions): Store;
+/**
+ * Run `fn` with a resolved {@link Store}, always closing it afterward. The
+ * canonical helper for one-shot CLI/MCP operations.
+ */
+export declare function withStore<T>(fn: (store: Store) => T | Promise<T>, env?: Env, options?: ResolveStoreOptions): Promise<T>;

package/dist/cloud-store.d.ts

@@ -0,0 +1,46 @@
+import { resolveStorageClient, type HasnaStorageClient } from "@hasna/contracts/client/storage";
+import type { Env } from "@hasna/contracts/mode";
+import type { Store } from "./store-interface.js";
+import type { AddDomainInput, Click, ClickInput, CreateLinkInput, Domain, Link, LinkStats } from "./types.js";
+/**
+ * Cloud-backed shortlinks store. All methods hit `/v1` over HTTPS with the
+ * bearer key. Mirrors the async `PgShortlinksStore` method signatures so it is a
+ * drop-in `RuntimeStore` for the CLI.
+ */
+export declare class CloudShortlinksStore implements Store {
+    private readonly client;
+    readonly kind: "cloud-http";
+    readonly transport: HasnaStorageClient["transport"];
+    private constructor();
+    /** Base `<origin>/v1` URL this store targets (for status/diagnostics). */
+    get baseUrl(): string;
+    /**
+     * Resolve a cloud store from the environment. Returns the store when the
+     * client-flip resolves to `cloud-http` (self_hosted + API_URL + API_KEY), else
+     * null so the caller falls back to the local store. Throws only when cloud was
+     * explicitly requested but is misconfigured (never silent local drift).
+     */
+    static fromEnv(env?: Env, overrides?: Parameters<typeof resolveStorageClient>[2]): CloudShortlinksStore | null;
+    close(): Promise<void>;
+    addDomain(input: AddDomainInput): Promise<Domain>;
+    listDomains(): Promise<Domain[]>;
+    getDomain(hostnameOrId: string): Promise<Domain | null>;
+    getDefaultDomain(): Promise<Domain | null>;
+    createLink(input: CreateLinkInput): Promise<Link>;
+    listLinks(options?: {
+        domain?: string;
+        activeOnly?: boolean;
+        limit?: number;
+    }): Promise<Link[]>;
+    getLink(domainOrSlug: string, maybeSlug?: string): Promise<Link | null>;
+    resolve(hostname: string, slug: string): Promise<Link | null>;
+    setLinkActive(domainOrSlug: string, maybeSlugOrActive: string | boolean, maybeActive?: boolean): Promise<Link>;
+    deleteLink(domainOrSlug: string, maybeSlug?: string): Promise<Link>;
+    recordClick(_link: Link, _input?: ClickInput): Promise<Click>;
+    getStats(domainOrSlug: string, maybeSlug?: string): Promise<LinkStats>;
+    totalStats(): Promise<{
+        domains: number;
+        links: number;
+        clicks: number;
+    }>;
+}

package/dist/cloudflare.js

@@ -1,13 +1,143 @@
 // @bun
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: __accessProp.bind(mod, key),
+        enumerable: true
+      });
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __require = import.meta.require;
+
 // src/cloudflare.ts
-import { mkdirSync, writeFileSync } from "fs";
+import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "fs";
 import { join as join2 } from "path";
 
 // src/config.ts
+import { existsSync, linkSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "fs";
+import { randomBytes } from "crypto";
 import { homedir } from "os";
 import { dirname, join, resolve } from "path";
 var SERVICE_NAME = "shortlinks";
 var DEFAULT_DATA_DIR = join(homedir(), ".hasna", SERVICE_NAME);
+function getDataDir() {
+  return resolve(process.env.SHORTLINKS_HOME || DEFAULT_DATA_DIR);
+}
+function ensureDataDir() {
+  const dir = getDataDir();
+  mkdirSync(dir, { recursive: true });
+  return dir;
+}
+function getConfigPath() {
+  return join(ensureDataDir(), "config.json");
+}
+function getClickSaltPath() {
+  return join(ensureDataDir(), "click-salt");
+}
+function getDatabasePath(explicitPath) {
+  if (explicitPath)
+    return resolve(explicitPath);
+  if (process.env.SHORTLINKS_DB)
+    return resolve(process.env.SHORTLINKS_DB);
+  return join(ensureDataDir(), `${SERVICE_NAME}.db`);
+}
+function readClickSaltFile(path) {
+  try {
+    const saved = readFileSync(path, "utf-8").trim();
+    return saved || null;
+  } catch {
+    return null;
+  }
+}
+function clickSaltError(path, error) {
+  const detail = error instanceof Error ? error.message : String(error);
+  return new Error(`Could not initialize click salt at ${path}. Set SHORTLINKS_CLICK_SALT or fix data directory permissions. ${detail}`);
+}
+function getClickSalt() {
+  const explicit = process.env.SHORTLINKS_CLICK_SALT?.trim();
+  if (explicit)
+    return explicit;
+  const path = getClickSaltPath();
+  const saved = readClickSaltFile(path);
+  if (saved)
+    return saved;
+  const generated = randomBytes(32).toString("hex");
+  const tempPath = `${path}.${process.pid}.${randomBytes(6).toString("hex")}.tmp`;
+  try {
+    writeFileSync(tempPath, `${generated}
+`, { flag: "wx", mode: 384 });
+    try {
+      linkSync(tempPath, path);
+      return generated;
+    } catch (error) {
+      const winner = readClickSaltFile(path);
+      if (winner)
+        return winner;
+      throw clickSaltError(path, error);
+    } finally {
+      try {
+        unlinkSync(tempPath);
+      } catch {}
+    }
+  } catch (error) {
+    const winner = readClickSaltFile(path);
+    if (winner)
+      return winner;
+    throw clickSaltError(path, error);
+  }
+}
+function loadConfig() {
+  const path = getConfigPath();
+  if (!existsSync(path))
+    return {};
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf-8"));
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function saveConfig(config) {
+  const path = getConfigPath();
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, `${JSON.stringify(config, null, 2)}
+`);
+}
+function updateConfig(patch) {
+  const next = {
+    ...loadConfig(),
+    ...patch,
+    cloudflare: {
+      ...loadConfig().cloudflare,
+      ...patch.cloudflare
+    }
+  };
+  saveConfig(next);
+  return next;
+}
 function normalizeHostname(input) {
   const raw = input.trim().toLowerCase();
   if (!raw)
@@ -27,6 +157,13 @@ function normalizeHostname(input) {
   }
   return hostname;
 }
+function formatShortUrl(hostname, slug, publicBaseUrl) {
+  if (publicBaseUrl) {
+    const base = publicBaseUrl.endsWith("/") ? publicBaseUrl : `${publicBaseUrl}/`;
+    return new URL(slug, base).toString();
+  }
+  return `https://${hostname}/${slug}`;
+}
 
 // src/cloudflare.ts
 function createCloudflarePlan(input) {
@@ -76,11 +213,11 @@ function generateWorkerScript() {
 function writeWorkerFiles(options = {}) {
   const outDir = options.outDir || "cloudflare";
   const workerName = options.workerName || "shortlinks";
-  mkdirSync(outDir, { recursive: true });
+  mkdirSync2(outDir, { recursive: true });
   const workerPath = join2(outDir, `${workerName}.js`);
   const wranglerPath = join2(outDir, "wrangler.example.toml");
-  writeFileSync(workerPath, generateWorkerScript());
-  writeFileSync(wranglerPath, `name = "${workerName}"
+  writeFileSync2(workerPath, generateWorkerScript());
+  writeFileSync2(wranglerPath, `name = "${workerName}"
 main = "${workerName}.js"
 compatibility_date = "2026-05-01"
 

package/dist/db/migrations.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Cloud Postgres migrations for the shortlinks serve service.
+ *
+ * PURE REMOTE (Amendment A1): these run against the shared RDS Postgres via the
+ * vendored storage kit's MigrationLedger. The service reads and writes the same
+ * cloud database — there is no local mirror, cache, or sync engine here.
+ *
+ * The domains/links/clicks schema uses SQLite-parity TEXT/INTEGER shapes so the
+ * existing SaaS-remnant tables are matched exactly
+ * (every statement is `IF NOT EXISTS` — applying the ledger never clobbers data).
+ * The api_keys table migrations come from @hasna/contracts/auth so the API-key
+ * middleware and the `contracts issue-key` issuer share one schema.
+ */
+import { type Migration } from "../generated/storage-kit/migrations.js";
+/**
+ * Ordered migrations for the shortlinks cloud schema, including the shared
+ * api_keys table from @hasna/contracts. Feed straight into the kit's
+ * MigrationLedger.
+ */
+export declare const SHORTLINKS_MIGRATIONS: readonly Migration[];

package/dist/generated/storage-kit/health.d.ts

@@ -0,0 +1,19 @@
+import type { TypedQueryClient } from "./query.js";
+import { type Migration, type MigrationRunnerOptions } from "./migrations.js";
+export interface HealthResult {
+    ok: boolean;
+    /** Round-trip latency of the probe query, in milliseconds. */
+    latencyMs: number;
+    error?: string;
+}
+/** Cheap reachability probe: `SELECT 1`. Never throws — reports `ok: false`. */
+export declare function checkHealth(client: TypedQueryClient): Promise<HealthResult>;
+export interface ReadyResult extends HealthResult {
+    /** Migration ids that are defined but not yet applied. */
+    pendingMigrations: string[];
+}
+/**
+ * Readiness probe: reachable AND fully migrated. Reports `ok: false` with the
+ * list of pending migration ids when the schema is behind.
+ */
+export declare function checkReady(client: TypedQueryClient, migrations: readonly Migration[], options?: MigrationRunnerOptions): Promise<ReadyResult>;

package/dist/generated/storage-kit/index.d.ts

@@ -0,0 +1,7 @@
+export declare const KIT_VERSION = "0.4.2";
+export * from "./mode.js";
+export * from "./tls.js";
+export * from "./query.js";
+export * from "./pool.js";
+export * from "./migrations.js";
+export * from "./health.js";

package/dist/generated/storage-kit/migrations.d.ts

@@ -0,0 +1,47 @@
+import type { TypedQueryClient } from "./query.js";
+/** Default ledger table name. Override per app if a legacy name exists. */
+export declare const DEFAULT_MIGRATION_LEDGER_TABLE = "schema_migrations";
+export interface Migration {
+    readonly id: string;
+    readonly sql: string;
+    readonly checksum: string;
+}
+export type MigrationState = "already_applied" | "pending";
+export interface MigrationPlanItem {
+    readonly migration: Migration;
+    readonly state: MigrationState;
+}
+export interface AppliedMigration {
+    readonly id: string;
+    readonly checksum: string;
+    readonly appliedAt: string;
+}
+export interface MigrationResult {
+    readonly dryRun: boolean;
+    readonly applied: AppliedMigration[];
+    readonly plan: MigrationPlanItem[];
+}
+/** Stable sha256 checksum for a migration's SQL text. */
+export declare function checksumSql(sql: string): string;
+/** Freeze a migration definition, computing its checksum from the SQL. */
+export declare function defineMigration(id: string, sql: string): Migration;
+export interface MigrationRunnerOptions {
+    ledgerTable?: string;
+}
+export declare class MigrationLedger {
+    private readonly client;
+    private readonly migrations;
+    private readonly ledgerTable;
+    constructor(client: TypedQueryClient, migrations: readonly Migration[], options?: MigrationRunnerOptions);
+    ensureLedger(): Promise<void>;
+    listApplied(): Promise<AppliedMigration[]>;
+    private readApplied;
+    /** Compute the migration plan and guard against drift/downgrade. */
+    private buildPlan;
+    /** Apply all pending migrations. With `dryRun`, report the plan only. */
+    migrate(opts?: {
+        dryRun?: boolean;
+    }): Promise<MigrationResult>;
+}
+/** Convenience: build a ledger and run all pending migrations. */
+export declare function createMigrationLedger(client: TypedQueryClient, migrations: readonly Migration[], options?: MigrationRunnerOptions): MigrationLedger;

package/dist/generated/storage-kit/mode.d.ts

@@ -0,0 +1,47 @@
+export declare const STORAGE_MODES: readonly ["local", "cloud"];
+export type StorageMode = (typeof STORAGE_MODES)[number];
+export declare const DEPRECATED_STORAGE_MODE_ALIASES: readonly ["remote", "hybrid", "self_hosted"];
+export type Env = Record<string, string | undefined>;
+export interface StorageModeNormalization {
+    mode: StorageMode;
+    /** The deprecated alias that was normalized to `cloud`, if any. */
+    deprecatedAlias: string | null;
+}
+/**
+ * Normalize a raw storage-mode string to the `local | cloud` runtime enum.
+ * Accepts deprecated aliases (`remote`, `hybrid`, `self_hosted`) and maps them
+ * to `cloud`. Throws on any other value.
+ */
+export declare function normalizeStorageMode(value: string): StorageModeNormalization;
+/** Upper-snake env token for an app name, e.g. `todos` -> `TODOS`. */
+export declare function envToken(name: string): string;
+export interface StorageEnvKeys {
+    /** `HASNA_<NAME>_STORAGE_MODE` then the optional `<NAME>_STORAGE_MODE` alias. */
+    modeKeys: string[];
+    /** `HASNA_<NAME>_DATABASE_URL` then the optional `<NAME>_DATABASE_URL` alias. */
+    databaseUrlKeys: string[];
+}
+/** Resolve the canonical env-key spec for an app's storage config. */
+export declare function storageEnvKeys(name: string): StorageEnvKeys;
+export interface StorageModeResolution {
+    mode: StorageMode;
+    /** Env key the mode came from, or `"default"`. */
+    source: string;
+    deprecatedAlias: string | null;
+    databaseUrlPresent: boolean;
+    /** Env key the database URL came from, or `null`. */
+    databaseUrlSource: string | null;
+    warning: string | null;
+}
+/**
+ * Resolve an app's storage mode from the environment per the contract env spec.
+ * Precedence: `HASNA_<NAME>_STORAGE_MODE`, then `<NAME>_STORAGE_MODE`, else
+ * `local`. Never reads secret values — only detects DATABASE_URL presence.
+ */
+export declare function resolveStorageMode(name: string, env?: Env): StorageModeResolution;
+/**
+ * Resolve the database URL value for an app, honoring the canonical then alias
+ * env keys. Returns `null` when unset. The caller is responsible for never
+ * logging the returned value.
+ */
+export declare function resolveDatabaseUrl(name: string, env?: Env): string | null;

package/dist/generated/storage-kit/pool.d.ts

@@ -0,0 +1,33 @@
+import type { Pool } from "pg";
+import { type TlsResolveOptions } from "./tls.js";
+import { type PoolQueryClient } from "./query.js";
+export interface CreatePgPoolOptions extends TlsResolveOptions {
+    connectionString: string;
+    /** Max clients in the pool. Defaults to pg's default (10). */
+    max?: number;
+    /** Idle client timeout (ms). */
+    idleTimeoutMillis?: number;
+    /** Connection acquisition timeout (ms). */
+    connectionTimeoutMillis?: number;
+    /** Application name reported to Postgres (shows in pg_stat_activity). */
+    applicationName?: string;
+}
+/** Build a `pg.Pool` with fleet-standard TLS handling. */
+export declare function createPgPool(options: CreatePgPoolOptions): Pool;
+export interface CreateCloudPoolFromEnvOptions extends TlsResolveOptions {
+    max?: number;
+    idleTimeoutMillis?: number;
+    connectionTimeoutMillis?: number;
+    applicationName?: string;
+}
+export interface CloudPoolFromEnv {
+    client: PoolQueryClient;
+    connectionSource: string;
+}
+/**
+ * Resolve mode + database URL from the environment and build a cloud pool.
+ *
+ * Throws when the resolved mode is not `cloud` (PURE REMOTE has no Postgres in
+ * `local` mode) or when the database URL is missing. Never logs the URL.
+ */
+export declare function createCloudPoolFromEnv(appName: string, options?: CreateCloudPoolFromEnvOptions): CloudPoolFromEnv;

package/dist/generated/storage-kit/query.d.ts

@@ -0,0 +1,35 @@
+import type { Pool, QueryResultRow } from "pg";
+export interface QueryResult<T extends QueryResultRow> {
+    rows: T[];
+    rowCount: number;
+}
+/**
+ * Minimal executor contract. `pg.Pool` and `pg.PoolClient` both satisfy the
+ * `query` method; the wrapper builds the rest on top so tests can substitute a
+ * lightweight shim without pulling in a live Postgres.
+ */
+export interface PgExecutor {
+    query<T extends QueryResultRow>(sql: string, params?: readonly unknown[]): Promise<{
+        rows: T[];
+        rowCount: number | null;
+    }>;
+}
+export interface TypedQueryClient {
+    query<T extends QueryResultRow>(sql: string, params?: readonly unknown[]): Promise<QueryResult<T>>;
+    many<T extends QueryResultRow>(sql: string, params?: readonly unknown[]): Promise<T[]>;
+    /** First row or `null`. Restored here after open-knowledge dropped it. */
+    get<T extends QueryResultRow>(sql: string, params?: readonly unknown[]): Promise<T | null>;
+    /** Exactly one row; throws if zero or more than one row is returned. */
+    one<T extends QueryResultRow>(sql: string, params?: readonly unknown[]): Promise<T>;
+    execute(sql: string, params?: readonly unknown[]): Promise<void>;
+}
+/** Wrap any `PgExecutor` (a Pool, a PoolClient, or a test shim) with the typed vocabulary. */
+export declare function wrapExecutor(executor: PgExecutor): TypedQueryClient;
+export interface PoolQueryClient extends TypedQueryClient {
+    readonly pool: Pool;
+    /** Run a callback inside a `BEGIN`/`COMMIT` transaction on a dedicated client. */
+    transaction<T>(fn: (client: TypedQueryClient) => Promise<T>): Promise<T>;
+    close(): Promise<void>;
+}
+/** Build a `PoolQueryClient` around a live `pg.Pool`. */
+export declare function createQueryClient(pool: Pool): PoolQueryClient;

package/dist/generated/storage-kit/tls.d.ts

@@ -0,0 +1,25 @@
+/** The `ssl` field shape accepted by `pg.Pool` / `pg.Client`. */
+export type PgSslConfig = boolean | {
+    rejectUnauthorized: boolean;
+    ca?: string;
+};
+export interface TlsResolveOptions {
+    /** Inline CA bundle (PEM). Wins over every other CA source. */
+    ca?: string;
+    /** Path to a CA bundle PEM file, e.g. the Amazon RDS global bundle. */
+    caCertPath?: string;
+    /** Environment used to discover PGSSLROOTCERT / NODE_EXTRA_CA_CERTS. */
+    env?: Record<string, string | undefined>;
+}
+export type SslMode = "disable" | "prefer" | "require" | "verify-ca" | "verify-full";
+/**
+ * Extract the effective `sslmode` from a Postgres connection string. Honors the
+ * `sslmode` query param and the legacy `ssl=true` boolean. Returns `disable`
+ * when TLS is not requested.
+ */
+export declare function sslModeFromConnectionString(connectionString: string): SslMode;
+/**
+ * Resolve the `pg` ssl config for a connection string. See the module header
+ * for the full mode table. Returns `undefined` when TLS should be off.
+ */
+export declare function resolveTlsConfig(connectionString: string, options?: TlsResolveOptions): PgSslConfig | undefined;

package/dist/index.d.ts

@@ -1,12 +1,15 @@
 export { ShortlinksDatabase, SQLITE_MIGRATIONS, makeId, now } from "./database.js";
 export { ShortlinksStore } from "./store.js";
-export { PgShortlinksStore, applyPostgresMigrations } from "./pg-store.js";
+export { LocalStore, ApiStore, resolveStore, withStore } from "./client-store.js";
+export { CloudShortlinksStore } from "./cloud-store.js";
+export type { Store, ListLinksOptions, TotalStats } from "./store-interface.js";
+export { PgShortlinksStore, createKitPgAdapter } from "./pg-store.js";
+export { SHORTLINKS_MIGRATIONS } from "./db/migrations.js";
+export { createServeApp } from "./serve/app.js";
+export { buildOpenApiDocument } from "./serve/openapi.js";
 export { createShortlinksHandler, serveShortlinks } from "./server.js";
 export { createCloudflarePlan, generateWorkerScript, writeWorkerFiles, upsertCloudflareDnsRecord } from "./cloudflare.js";
 export { createLocalSetupPlan, registerMachinesDns } from "./local.js";
-export { PG_MIGRATIONS } from "./pg-migrations.js";
-export { CANONICAL_SHORTLINKS_POSTGRES_CLUSTER, CANONICAL_SHORTLINKS_POSTGRES_DATABASE, CANONICAL_SHORTLINKS_RUNTIME_SECRET_PATH, SHORTLINKS_RUNTIME_ENV, SHORTLINKS_RUNTIME_FALLBACK_ENV, assertShortlinksPostgresConfig, getCanonicalShortlinksPostgresConfig, getShortlinksDatabaseSsl, getShortlinksDatabaseUrl, getShortlinksRuntimeEnvName, getShortlinksRuntimeStatus, getShortlinksStoreMode, loadShortlinksRuntimeConfig, parseShortlinksStoreMode, redactDatabaseUrl, } from "./runtime.js";
 export { formatShortUrl, getConfigPath, getDataDir, getDatabasePath, loadConfig, normalizeHostname, saveConfig } from "./config.js";
 export { normalizeSlug, randomToken } from "./slug.js";
 export type { AddDomainInput, Click, ClickInput, CreateLinkInput, Domain, Link, LinkStats } from "./types.js";
-export type { CanonicalShortlinksPostgresConfig, RuntimeEnvStatus, ShortlinksPostgresConfig, ShortlinksRuntimeConfig, ShortlinksRuntimeEnv, ShortlinksRuntimeStatus, ShortlinksStoreMode, } from "./runtime.js";