@open-mercato/shared 0.4.2-canary-c02407ff85

package/src/lib/query/join-utils.ts

@@ -0,0 +1,238 @@
+import type { Knex } from 'knex'
+import type { QueryOptions, QueryJoinEdge } from './types'
+import type { FilterOp } from './types'
+
+export type NormalizedFilter = { field: string; op: FilterOp; value?: unknown }
+
+export function normalizeFilters(filters?: QueryOptions['filters']): NormalizedFilter[] {
+  if (!filters) return []
+  const normalizeField = (key: string) => (key.startsWith('cf_') ? `cf:${key.slice(3)}` : key)
+  if (Array.isArray(filters)) {
+    return (filters as any[]).map((f) => ({
+      ...f,
+      field: normalizeField(String((f as any).field)),
+    }))
+  }
+  const out: NormalizedFilter[] = []
+  const obj = filters as Record<string, unknown>
+  const push = (field: string, op: FilterOp, value?: unknown) => {
+    out.push({ field, op, value })
+  }
+  for (const [rawKey, rawVal] of Object.entries(obj)) {
+    const field = normalizeField(rawKey)
+    if (rawVal !== null && typeof rawVal === 'object' && !Array.isArray(rawVal)) {
+      for (const [opKey, opVal] of Object.entries(rawVal as Record<string, unknown>)) {
+        switch (opKey) {
+          case '$eq':
+            push(field, 'eq', opVal)
+            break
+          case '$ne':
+            push(field, 'ne', opVal)
+            break
+          case '$gt':
+            push(field, 'gt', opVal)
+            break
+          case '$gte':
+            push(field, 'gte', opVal)
+            break
+          case '$lt':
+            push(field, 'lt', opVal)
+            break
+          case '$lte':
+            push(field, 'lte', opVal)
+            break
+          case '$in':
+            push(field, 'in', opVal)
+            break
+          case '$nin':
+            push(field, 'nin', opVal)
+            break
+          case '$like':
+            push(field, 'like', opVal)
+            break
+          case '$ilike':
+            push(field, 'ilike', opVal)
+            break
+          case '$exists':
+            push(field, 'exists', opVal)
+            break
+        }
+      }
+    } else {
+      push(field, 'eq', rawVal)
+    }
+  }
+  return out
+}
+
+export type ResolvedJoin = {
+  alias: string
+  table: string
+  fromAlias: string
+  fromField: string
+  toField: string
+  type: 'left' | 'inner'
+}
+
+export type BaseFilter = NormalizedFilter & { qualified?: string }
+export type JoinFilter = { alias: string; column: string; op: FilterOp; value?: unknown }
+
+export function resolveJoins(
+  baseTable: string,
+  joins: QueryJoinEdge[] | null | undefined,
+  resolveTable: (entityId: string) => string | null,
+): ResolvedJoin[] {
+  if (!joins || joins.length === 0) return []
+  const resolved: ResolvedJoin[] = []
+  const seen = new Set<string>()
+  for (const entry of joins) {
+    if (!entry || typeof entry !== 'object') continue
+    const alias = typeof entry.alias === 'string' ? entry.alias.trim() : ''
+    if (!alias) continue
+    if (seen.has(alias)) continue
+    const table =
+      entry.table ??
+      (entry.entityId ? resolveTable(String(entry.entityId)) : null)
+    if (!table) continue
+    const fromField = entry.from?.field?.trim()
+    const toField = entry.to?.field?.trim()
+    if (!fromField || !toField) continue
+    const fromAliasRaw = entry.from?.alias?.trim()
+    const fromAlias = fromAliasRaw && fromAliasRaw.length > 0 ? fromAliasRaw : 'base'
+    const type: 'left' | 'inner' = entry.type === 'inner' ? 'inner' : 'left'
+    resolved.push({ alias, table, fromAlias, fromField, toField, type })
+    seen.add(alias)
+  }
+  return resolved
+}
+
+export function buildJoinChain(
+  alias: string,
+  joinMap: Map<string, ResolvedJoin>,
+  baseTable: string,
+  visited: Set<string> = new Set(),
+): ResolvedJoin[] {
+  if (visited.has(alias)) {
+    throw new Error(`QueryEngine: circular join reference detected for alias ${alias}`)
+  }
+  const cfg = joinMap.get(alias)
+  if (!cfg) return []
+  visited.add(alias)
+  if (!cfg.fromAlias || cfg.fromAlias === 'base' || cfg.fromAlias === baseTable) {
+    return [cfg]
+  }
+  const parentChain = buildJoinChain(cfg.fromAlias, joinMap, baseTable, visited)
+  if (parentChain.length === 0) return []
+  return [...parentChain, cfg]
+}
+
+export function partitionFilters(
+  baseTable: string,
+  filters: NormalizedFilter[],
+  joinMap: Map<string, ResolvedJoin>,
+): { baseFilters: BaseFilter[]; joinFilters: Map<string, JoinFilter[]> } {
+  const baseFilters: BaseFilter[] = []
+  const joinFilters = new Map<string, JoinFilter[]>()
+  for (const filter of filters) {
+    const field = String(filter.field)
+    if (field.startsWith('cf:')) continue
+    const parts = field.split('.')
+    if (parts.length === 2) {
+      const [aliasNameRaw, column] = parts
+      const aliasName = aliasNameRaw || ''
+      if (joinMap.has(aliasName)) {
+        const list = joinFilters.get(aliasName) ?? []
+        list.push({ alias: aliasName, column, op: filter.op, value: filter.value })
+        joinFilters.set(aliasName, list)
+        continue
+      }
+      if (aliasName === baseTable || aliasName === 'base') {
+        baseFilters.push({
+          field: column,
+          op: filter.op,
+          value: filter.value,
+          qualified: `${baseTable}.${column}`,
+        })
+        continue
+      }
+    }
+    baseFilters.push({ ...filter })
+  }
+  return { baseFilters, joinFilters }
+}
+
+type ApplyJoinFiltersOptions = {
+  knex: Knex
+  baseTable: string
+  builder: Knex.QueryBuilder
+  joinMap: Map<string, ResolvedJoin>
+  joinFilters: Map<string, JoinFilter[]>
+  aliasTables: Map<string, string>
+  qualifyBase: (column: string) => string
+  applyAliasScope: (builder: Knex.QueryBuilder, alias: string, table: string) => Promise<void> | void
+  applyFilterOp: (builder: Knex.QueryBuilder, column: string, op: FilterOp, value?: unknown) => void
+  columnExists?: (table: string, column: string) => Promise<boolean> | boolean
+}
+
+export async function applyJoinFilters({
+  knex,
+  baseTable,
+  builder,
+  joinMap,
+  joinFilters,
+  aliasTables,
+  qualifyBase,
+  applyAliasScope,
+  applyFilterOp,
+  columnExists,
+}: ApplyJoinFiltersOptions): Promise<Knex.QueryBuilder> {
+  const resolveAliasName = (aliasName?: string | null) => {
+    if (!aliasName || aliasName === 'base') return baseTable
+    return aliasName
+  }
+
+  for (const [alias, filtersForAlias] of joinFilters.entries()) {
+    const chain = buildJoinChain(alias, joinMap, baseTable)
+    if (!chain.length) continue
+    const first = chain[0]
+    const sub = knex({ [first.alias]: first.table }).select(1)
+    await applyAliasScope(sub, first.alias, first.table)
+    const parentAlias = resolveAliasName(first.fromAlias)
+    if (parentAlias === baseTable) {
+      sub.whereRaw('?? = ??', [`${first.alias}.${first.toField}`, qualifyBase(first.fromField)])
+    } else {
+      sub.whereRaw('?? = ??', [`${first.alias}.${first.toField}`, `${parentAlias}.${first.fromField}`])
+    }
+    for (const cfg of chain.slice(1)) {
+      const joinArgs = { [cfg.alias]: cfg.table }
+      const parent = resolveAliasName(cfg.fromAlias)
+      const joinFn = function (this: Knex.JoinClause) {
+        const left = `${cfg.alias}.${cfg.toField}`
+        const right = parent === baseTable ? qualifyBase(cfg.fromField) : `${parent}.${cfg.fromField}`
+        this.on(knex.raw('?? = ??', [left, right]))
+      }
+      if (cfg.type === 'inner') sub.join(joinArgs, joinFn)
+      else sub.leftJoin(joinArgs, joinFn)
+      await applyAliasScope(sub, cfg.alias, cfg.table)
+    }
+    let existsDirective: boolean | null = null
+    for (const filter of filtersForAlias) {
+      if (filter.op === 'exists') {
+        if (filter.value === false) existsDirective = false
+        else if (existsDirective === null) existsDirective = true
+        continue
+      }
+      const targetTable = aliasTables.get(filter.alias)
+      if (!targetTable) continue
+      if (columnExists) {
+        const exists = await columnExists(targetTable, filter.column)
+        if (!exists) continue
+      }
+      const qualified = `${filter.alias}.${filter.column}`
+      applyFilterOp(sub, qualified, filter.op, filter.value)
+    }
+    if (existsDirective === false) builder = builder.whereNotExists(sub)
+    else builder = builder.whereExists(sub)
+  }
+  return builder
+}

package/src/lib/query/types.ts

@@ -0,0 +1,121 @@
+import type { EntityId } from '@open-mercato/shared/modules/entities'
+import type { Profiler } from '../profiler'
+
+export type FilterOp = 'eq' | 'ne' | 'gt' | 'gte' | 'lt' | 'lte' | 'in' | 'nin' | 'like' | 'ilike' | 'exists'
+
+export enum SortDir {
+  Asc = 'asc',
+  Desc = 'desc',
+}
+
+export type FieldSelector = string // base field or custom field key (prefixed with 'cf:')
+
+export type Filter = {
+  field: FieldSelector
+  op: FilterOp
+  value?: any
+}
+
+export type Sort = { field: FieldSelector; dir?: SortDir }
+
+export type Page = { page?: number; pageSize?: number }
+
+// Mongo/Medusa-style filter operators (typed)
+export type WhereOps<T> = {
+  $eq?: T
+  $ne?: T | null
+  $gt?: T extends number | Date ? T : never
+  $gte?: T extends number | Date ? T : never
+  $lt?: T extends number | Date ? T : never
+  $lte?: T extends number | Date ? T : never
+  $in?: T[]
+  $nin?: T[]
+  $like?: T extends string ? string : never
+  $ilike?: T extends string ? string : never
+  $exists?: boolean
+}
+
+// A field filter can be a direct value (equals) or ops object
+export type WhereValue<T = any> = T | WhereOps<T>
+
+// Generic shape for object filters. If you have a typed map of field→type,
+// pass it as the generic to get end-to-end typing.
+// Example: Where<{
+//   id: string; title: string; created_at: Date; 'cf:severity': number
+// }>
+export type Where<Fields extends Record<string, any> = Record<string, any>> =
+  Partial<{ [K in keyof Fields]: WhereValue<Fields[K]> }> & Record<string, WhereValue>
+
+export type QueryCustomFieldJoin = {
+  fromField: string
+  toField: string
+  type?: 'left' | 'inner'
+}
+
+export type QueryCustomFieldSource = {
+  entityId: EntityId
+  table?: string
+  alias?: string
+  recordIdColumn?: string
+  join?: QueryCustomFieldJoin
+  tenantField?: string
+  organizationField?: string
+}
+
+export type QueryJoinEdge = {
+  alias: string
+  table?: string
+  entityId?: EntityId
+  from: {
+    alias?: string
+    field: string
+  }
+  to: {
+    field: string
+  }
+  type?: 'left' | 'inner'
+}
+
+export type QueryOptions = {
+  fields?: FieldSelector[] // base fields and/or 'cf:<key>' for custom fields
+  includeExtensions?: boolean | string[] // include all registered extensions or only specific ones by entity id
+  includeCustomFields?: boolean | string[] // include all CFs or specific keys
+  // Accept classic array syntax or Mongo-style object syntax
+  filters?: Filter[] | Where
+  sort?: Sort[]
+  page?: Page
+  organizationId?: string // enforce multi-tenant scope
+  tenantId?: string // enforce tenant scope
+  // Optional list of organization ids to scope results. Takes precedence over organizationId.
+  organizationIds?: string[]
+  // Soft-delete behavior: when false (default), rows with non-null deleted_at
+  // are excluded if the base table has that column. Set true to include them.
+  withDeleted?: boolean
+  customFieldSources?: QueryCustomFieldSource[]
+  joins?: QueryJoinEdge[]
+  profiler?: Profiler
+}
+
+export type PartialIndexWarning = {
+  entity: EntityId
+  entityLabel?: string | null
+  baseCount?: number | null
+  indexedCount?: number | null
+  scope?: 'scoped' | 'global'
+}
+
+export type QueryResultMeta = {
+  partialIndexWarning?: PartialIndexWarning
+}
+
+export type QueryResult<T = any> = {
+  items: T[]
+  page: number
+  pageSize: number
+  total: number
+  meta?: QueryResultMeta
+}
+
+export interface QueryEngine {
+  query<T = any>(entity: EntityId, opts?: QueryOptions): Promise<QueryResult<T>>
+}

package/src/lib/search/config.ts

@@ -0,0 +1,49 @@
+import { parseBooleanWithDefault } from '@open-mercato/shared/lib/boolean'
+
+export type SearchConfig = {
+  enabled: boolean
+  minTokenLength: number
+  enablePartials: boolean
+  hashAlgorithm: 'sha256' | 'sha1' | 'md5'
+  storeRawTokens: boolean
+  blocklistedFields: string[]
+}
+
+const DEFAULT_BLOCKLIST = ['password', 'token', 'secret', 'hash']
+
+function parseBoolean(raw: string | undefined, fallback: boolean): boolean {
+  return parseBooleanWithDefault(raw, fallback)
+}
+
+function parseNumber(raw: string | undefined, fallback: number, min = 1): number {
+  if (raw == null) return fallback
+  const value = Number.parseInt(raw, 10)
+  if (!Number.isFinite(value)) return fallback
+  if (value < min) return fallback
+  return value
+}
+
+function parseHashAlgorithm(raw: string | undefined): 'sha256' | 'sha1' | 'md5' {
+  const value = (raw ?? '').trim().toLowerCase()
+  if (value === 'sha1') return 'sha1'
+  if (value === 'md5') return 'md5'
+  return 'sha256'
+}
+
+export function resolveSearchConfig(): SearchConfig {
+  return {
+    enabled: parseBoolean(process.env.OM_SEARCH_ENABLED, true),
+    minTokenLength: parseNumber(process.env.OM_SEARCH_MIN_LEN, 3, 1),
+    enablePartials: parseBoolean(process.env.OM_SEARCH_ENABLE_PARTIAL, true),
+    hashAlgorithm: parseHashAlgorithm(process.env.OM_SEARCH_HASH_ALGO),
+    storeRawTokens: parseBoolean(process.env.OM_SEARCH_STORE_RAW_TOKENS, false),
+    blocklistedFields: (process.env.OM_SEARCH_FIELD_BLOCKLIST ?? '')
+      .split(',')
+      .map((entry) => entry.trim())
+      .filter((entry) => entry.length > 0)
+      .filter((value, index, arr) => arr.indexOf(value) === index)
+      .map((entry) => entry.toLowerCase())
+      .concat(DEFAULT_BLOCKLIST)
+      .filter((value, index, arr) => arr.indexOf(value) === index),
+  }
+}

package/src/lib/search/tokenize.ts

@@ -0,0 +1,45 @@
+import crypto from 'crypto'
+import { resolveSearchConfig, type SearchConfig } from './config'
+
+export type TokenizationResult = {
+  tokens: string[]
+  hashes: string[]
+}
+
+function normalizeText(text: string): string {
+  return text
+    .normalize('NFKD')
+    .replace(/[\u0300-\u036f]/g, '')
+    .replace(/[%_]/g, ' ')
+    .toLowerCase()
+}
+
+function splitTokens(text: string, minLength: number): string[] {
+  return normalizeText(text)
+    .split(/[^a-z0-9]+/i)
+    .filter((token) => token.length >= minLength)
+}
+
+function expandToken(token: string, config: SearchConfig): string[] {
+  if (!config.enablePartials) return [token]
+  const results: string[] = []
+  for (let i = config.minTokenLength; i <= token.length; i += 1) {
+    results.push(token.slice(0, i))
+  }
+  return results
+}
+
+export function hashToken(token: string, config?: SearchConfig): string {
+  const cfg = config ?? resolveSearchConfig()
+  return crypto.createHash(cfg.hashAlgorithm).update(token).digest('hex')
+}
+
+export function tokenizeText(text: string, config?: SearchConfig): TokenizationResult {
+  const cfg = config ?? resolveSearchConfig()
+  const baseTokens = splitTokens(text, cfg.minTokenLength)
+  const expanded = baseTokens.flatMap((token) => expandToken(token, cfg))
+  const unique = Array.from(new Set(expanded))
+  const tokens = unique.filter((token) => token.length >= cfg.minTokenLength)
+  const hashes = tokens.map((token) => hashToken(token, cfg))
+  return { tokens, hashes }
+}

package/src/lib/slugify.ts

@@ -0,0 +1,28 @@
+export type SlugifyOptions = {
+  replacement?: string
+  allowedChars?: string
+  trimReplacement?: boolean
+}
+
+const DEFAULT_REPLACEMENT = '-'
+const DEFAULT_ALLOWED_CHARS = '-'
+
+const escapeRegex = (value: string): string => value.replace(/[\\^$.*+?()[\]{}|\-]/g, '\\$&')
+
+export function slugify(value: string, options: SlugifyOptions = {}): string {
+  const replacement = options.replacement ?? DEFAULT_REPLACEMENT
+  const allowedChars = options.allowedChars ?? DEFAULT_ALLOWED_CHARS
+  const trimReplacement = options.trimReplacement ?? true
+  const normalized = value.toLowerCase().trim()
+  if (!normalized) return ''
+  const escapedAllowed = escapeRegex(allowedChars)
+  const invalidPattern = new RegExp(`[^a-z0-9${escapedAllowed}]+`, 'g')
+  const replaced = normalized.replace(invalidPattern, replacement)
+  if (!trimReplacement || replacement.length !== 1 || !replaced) return replaced
+  const char = replacement
+  let start = 0
+  let end = replaced.length
+  while (start < end && replaced[start] === char) start += 1
+  while (end > start && replaced[end - 1] === char) end -= 1
+  return replaced.slice(start, end)
+}

package/src/lib/testing/bootstrap.ts

@@ -0,0 +1,124 @@
+/**
+ * Test Bootstrap Utility
+ *
+ * Provides a centralized way to bootstrap dependencies for tests.
+ * This utility allows tests to register only the dependencies they need
+ * without importing the full app bootstrap.
+ *
+ * Usage in tests:
+ *
+ * ```typescript
+ * import { bootstrapTest, resetTestBootstrap } from '@open-mercato/shared/lib/testing/bootstrap'
+ *
+ * beforeEach(async () => {
+ *   resetTestBootstrap()
+ *   await bootstrapTest({
+ *     modules: mockModules,
+ *     entityIds: mockEntityIds,
+ *   })
+ * })
+ * ```
+ *
+ * For tests that use jest.resetModules(), import dynamically:
+ *
+ * ```typescript
+ * beforeEach(async () => {
+ *   jest.resetModules()
+ *   const { registerModules } = await import('@open-mercato/shared/modules/registry')
+ *   registerModules(mockModules as any)
+ * })
+ * ```
+ */
+
+import type { Module } from '../../modules/registry'
+
+export type EntityIds = Record<string, Record<string, string>>
+
+export interface TestBootstrapOptions {
+  /** Modules to register (for i18n, query engine, etc.) */
+  modules?: Module[]
+  /** Entity IDs to register (for encryption, indexing) */
+  entityIds?: EntityIds
+  /** ORM entities to register (rarely needed in unit tests) */
+  ormEntities?: any[]
+  /** DI registrars to register (rarely needed in unit tests) */
+  diRegistrars?: Array<(container: any) => void>
+}
+
+let _testBootstrapped = false
+
+/**
+ * Bootstrap dependencies for tests.
+ * Call this in beforeEach or beforeAll to set up required registrations.
+ */
+export async function bootstrapTest(options: TestBootstrapOptions = {}): Promise<void> {
+  const { modules, entityIds, ormEntities, diRegistrars } = options
+
+  if (modules !== undefined) {
+    // Import lazily to avoid circular dependencies
+    const { registerModules } = await import('../modules/registry.js')
+    registerModules(modules)
+  }
+
+  if (entityIds !== undefined) {
+    const { registerEntityIds } = await import('../encryption/entityIds.js')
+    registerEntityIds(entityIds)
+  }
+
+  if (ormEntities !== undefined) {
+    const { registerOrmEntities } = await import('../db/mikro.js')
+    registerOrmEntities(ormEntities)
+  }
+
+  if (diRegistrars !== undefined) {
+    const { registerDiRegistrars } = await import('../di/container.js')
+    registerDiRegistrars(diRegistrars)
+  }
+
+  _testBootstrapped = true
+}
+
+/**
+ * Reset the test bootstrap state.
+ * Call this in beforeEach when you need fresh state between tests.
+ *
+ * Note: This only resets the test bootstrap flag. To fully reset
+ * registration state, you may need to use jest.resetModules() and
+ * re-import the registration functions.
+ */
+export function resetTestBootstrap(): void {
+  _testBootstrapped = false
+}
+
+/**
+ * Check if test bootstrap has been called.
+ */
+export function isTestBootstrapped(): boolean {
+  return _testBootstrapped
+}
+
+/**
+ * Helper to create minimal mock modules for testing.
+ */
+export function createMockModules(overrides: Partial<Module>[] = []): Module[] {
+  return overrides.map((override, index) => ({
+    id: override.id || `test-module-${index}`,
+    ...override,
+  })) as Module[]
+}
+
+/**
+ * Helper to create minimal mock entity IDs for testing.
+ */
+export function createMockEntityIds(
+  entities: Record<string, string[]>
+): EntityIds {
+  const result: EntityIds = {}
+  for (const [module, entityNames] of Object.entries(entities)) {
+    result[module] = {}
+    for (const name of entityNames) {
+      result[module][name] = `${module}:${name}`
+    }
+  }
+  return result
+}

package/src/lib/testing/index.ts

@@ -0,0 +1,15 @@
+/**
+ * Testing utilities for @open-mercato packages
+ */
+
+export {
+  bootstrapTest,
+  resetTestBootstrap,
+  isTestBootstrapped,
+  createMockModules,
+  createMockEntityIds,
+  type TestBootstrapOptions,
+  type EntityIds,
+} from './bootstrap'
+
+export { renderWithProviders } from './renderWithProviders'

package/src/lib/testing/renderWithProviders.tsx

@@ -0,0 +1,31 @@
+import * as React from 'react'
+import type { RenderOptions } from '@testing-library/react'
+import { render } from '@testing-library/react'
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
+import { I18nProvider } from '@open-mercato/shared/lib/i18n/context'
+
+type ProviderOptions = {
+  locale?: string
+  dict?: Record<string, unknown>
+  queryClient?: QueryClient
+}
+
+export function renderWithProviders(
+  ui: React.ReactElement,
+  options?: RenderOptions & ProviderOptions,
+) {
+  const { locale = 'en', dict = {}, queryClient = new QueryClient(), ...rest } = options ?? {}
+
+  function Wrapper({ children }: { children: React.ReactNode }) {
+    return (
+      <QueryClientProvider client={queryClient}>
+        {/* @ts-expect-error shared provider accepts loose dict shape */}
+        <I18nProvider locale={locale} dict={dict}>
+          {children}
+        </I18nProvider>
+      </QueryClientProvider>
+    )
+  }
+
+  return render(ui, { wrapper: Wrapper, ...rest })
+}

package/src/lib/url.ts

@@ -0,0 +1,12 @@
+export function getAppBaseUrl(req: Request): string {
+  const url = new URL(req.url)
+  return (
+    process.env.NEXT_PUBLIC_APP_URL ||
+    process.env.APP_URL ||
+    `${url.protocol}//${url.host}`
+  )
+}
+
+export function toAbsoluteUrl(req: Request, path: string): string {
+  return new URL(path, getAppBaseUrl(req)).toString()
+}

package/src/lib/utils.ts

@@ -0,0 +1,17 @@
+import { clsx, type ClassValue } from "clsx"
+import { twMerge } from "tailwind-merge"
+
+export function cn(...inputs: ClassValue[]) {
+  return twMerge(clsx(inputs))
+}
+
+export function slugifyTagLabel(label: string): string {
+  return (
+    label
+      .toLowerCase()
+      .trim()
+      .replace(/[^a-z0-9]+/g, "-")
+      .replace(/^-+|-+$/g, "")
+      .slice(0, 80) || `tag-${Math.random().toString(36).slice(2, 10)}`
+  )
+}

package/src/lib/version.ts

@@ -0,0 +1,5 @@
+// Application version - replaced at build time by esbuild plugin
+// The actual version is injected during the build process in build.mjs
+// This source file uses a placeholder that gets replaced in dist/
+export const APP_VERSION = '0.0.0-dev'
+export const appVersion = APP_VERSION