@almadar/orb 4.3.0 → 4.7.0

package/README.md

@@ -1,45 +1,83 @@
-# @almadar/cli
+# @almadar/orb
 
-Almadar CLI - Compile Almadar schemas to full-stack applications.
+Orb CLI — compile .orb programs to full-stack applications.
 
 ## Installation
 
 ```bash
-npm install -g @almadar/cli
+npm install -g @almadar/orb
+```
+
+Or use the curl installer:
+
+```bash
+curl -fsSL https://orb.almadar.io/install.sh | sh
 ```
 
 ## Usage
 
 ```bash
-# Validate a schema
-almadar validate schema.orb
+# Validate an .orb file (0 errors, 0 warnings required)
+orbital validate app.orb
 
-# Compile to TypeScript (React + Express)
-almadar compile schema.orb --shell typescript
+# Lower .lolo syntax to .orb JSON IR
+orbital emit-orb app.orb
 
-# Compile to Python (FastAPI + PyTorch)
-almadar compile schema.orb --shell python
+# Compile to TypeScript shell
+orbital compile app.orb --shell typescript
 
 # Start development server
-almadar dev schema.orb
+orbital dev app.orb
+```
+
+## Quick Example
+
+```lolo
+orbital TaskApp {
+  entity Task [persistent: tasks] {
+    id     : string!
+    title  : string!
+    status : string = "pending"
+  }
+
+  trait TaskBrowser -> Task [interaction] {
+    state browsing {
+      INIT -> browsing
+        (fetch Task)
+        (render-ui main { type: "entity-table", entity: "Task", fields: ["title", "status"] })
+      CREATE -> creating
+        (render-ui modal { type: "modal", isOpen: true, title: "New Task",
+          children: [{ type: "form-section", entity: "Task", fields: ["title", "status"], mode: "create" }] })
+    }
+    state creating {
+      SAVE -> browsing
+        (persist create Task @payload.data)
+        (render-ui modal null)
+      CANCEL -> browsing
+        (render-ui modal null)
+    }
+  }
+
+  page "/tasks" -> TaskBrowser
+}
 ```
 
 ## Commands
 
 | Command | Description |
 |---------|-------------|
-| `almadar validate <file>` | Validate an Almadar schema |
-| `almadar parse <file>` | Parse and display schema information |
-| `almadar compile <file>` | Compile schema to generated code |
-| `almadar serve <file>` | Start the Almadar server runtime |
-| `almadar gui <file>` | Start the Almadar desktop GUI |
-| `almadar dev <file>` | Start both server and client (dev mode) |
+| `orbital validate <file>` | Validate an .orb file |
+| `orbital emit-orb <file>` | Lower .lolo to .orb JSON (stdout) |
+| `orbital compile <file>` | Compile to generated code |
+| `orbital dev <file>` | Start development server |
+| `orbital new <name>` | Create a new project |
 
 ## Documentation
 
-- [Getting Started](https://almadar.io/docs/en/getting-started)
-- [CLI Reference](https://almadar.io/docs/en/reference/cli)
+- [Getting Started](https://orb.almadar.io/docs/getting-started/introduction)
+- [CLI Reference](https://orb.almadar.io/docs/reference/cli)
+- [Language Reference](https://orb.almadar.io/docs/core-concepts/entities)
 
 ## License
 
-MIT
+BSL 1.1

package/bin/{almadar → orb}

@@ -4,19 +4,18 @@ const { execFileSync } = require('child_process');
 const path = require('path');
 const fs = require('fs');
 
-const BINARY_NAME = process.platform === 'win32' ? 'almadar.exe' : 'almadar';
+const BINARY_NAME = process.platform === 'win32' ? 'orb.exe' : 'orb';
 
 function getBinaryPath() {
   const platform = process.platform;
   const arch = process.arch;
 
-  // Map Node.js platform/arch to package names
   const platformMap = {
-    'darwin-x64': '@almadar/cli-darwin-x64',
-    'darwin-arm64': '@almadar/cli-darwin-arm64',
-    'linux-x64': '@almadar/cli-linux-x64',
-    'linux-arm64': '@almadar/cli-linux-arm64',
-    'win32-x64': '@almadar/cli-windows-x64',
+    'darwin-x64': '@almadar/orb-darwin-x64',
+    'darwin-arm64': '@almadar/orb-darwin-arm64',
+    'linux-x64': '@almadar/orb-linux-x64',
+    'linux-arm64': '@almadar/orb-linux-arm64',
+    'win32-x64': '@almadar/orb-windows-x64',
   };
 
   const key = `${platform}-${arch}`;
@@ -24,64 +23,71 @@ function getBinaryPath() {
 
   if (!packageName) {
     console.error(`Unsupported platform: ${platform}-${arch}`);
-    console.error('Supported platforms: darwin-x64, darwin-arm64, linux-x64, linux-arm64, win32-x64');
+    console.error('Supported: darwin-x64, darwin-arm64, linux-x64, linux-arm64, win32-x64');
     process.exit(1);
   }
 
-  // Try to find the binary in node_modules
   const possiblePaths = [
-    // Installed as dependency
     path.join(__dirname, '..', 'node_modules', packageName, BINARY_NAME),
-    // Hoisted to parent node_modules
     path.join(__dirname, '..', '..', packageName, BINARY_NAME),
-    // Global install
     path.join(__dirname, '..', '..', '..', packageName, BINARY_NAME),
   ];
 
   for (const binaryPath of possiblePaths) {
     if (fs.existsSync(binaryPath)) {
-      return binaryPath;
+      return { binaryPath, platformDir: path.dirname(binaryPath) };
     }
   }
 
-  console.error(`Could not find Almadar binary for ${platform}-${arch}`);
-  console.error('Please try reinstalling: npm install -g @almadar/cli');
+  console.error(`Could not find Orb binary for ${platform}-${arch}`);
+  console.error('Try reinstalling: npm install -g @almadar/orb');
   process.exit(1);
 }
 
 function getShellsDir() {
-  // If user has set ORBITAL_SHELLS_DIR, respect it
   if (process.env.ORBITAL_SHELLS_DIR) {
     return process.env.ORBITAL_SHELLS_DIR;
   }
 
-  // Look for shells bundled with this package
   const possiblePaths = [
-    // Shells in same package
     path.join(__dirname, '..', 'shells'),
-    // Global install - shells might be one level up
-    path.join(__dirname, '..', '..', '@almadar', 'cli', 'shells'),
+    path.join(__dirname, '..', '..', '@almadar', 'orb', 'shells'),
   ];
 
   for (const shellsPath of possiblePaths) {
-    if (fs.existsSync(shellsPath) && fs.existsSync(path.join(shellsPath, 'typescript-shell'))) {
+    if (fs.existsSync(shellsPath) && (
+      fs.existsSync(path.join(shellsPath, 'almadar-shell')) ||
+      fs.existsSync(path.join(shellsPath, 'typescript-shell'))
+    )) {
       return shellsPath;
     }
   }
 
-  // No bundled shells found - binary will use its fallback or error
   return null;
 }
 
-const binaryPath = getBinaryPath();
+const { binaryPath, platformDir } = getBinaryPath();
 const shellsDir = getShellsDir();
 
-// Build environment with ORBITAL_SHELLS_DIR if we found shells
 const env = { ...process.env };
+
 if (shellsDir) {
   env.ORBITAL_SHELLS_DIR = shellsDir;
 }
 
+// Bun runtime (sibling to Rust binary in platform package)
+const bunName = process.platform === 'win32' ? 'bun.exe' : 'bun';
+const bunPath = path.join(platformDir, bunName);
+if (fs.existsSync(bunPath)) {
+  env.ORB_BUN_PATH = bunPath;
+}
+
+// Agent dist (agent/ directory in platform package)
+const agentDir = path.join(platformDir, 'agent');
+if (fs.existsSync(agentDir)) {
+  env.ORB_AGENT_DIR = agentDir;
+}
+
 try {
   execFileSync(binaryPath, process.argv.slice(2), {
     stdio: 'inherit',

package/package.json

@@ -1,16 +1,16 @@
 {
   "name": "@almadar/orb",
-  "version": "4.3.0",
-  "description": "Orb CLI - Compile Orbital schemas to full-stack applications",
+  "version": "4.7.0",
+  "description": "Orb CLI - deterministic when it can be, intelligent when it needs to be",
   "license": "BSL-1.1",
   "repository": {
     "type": "git",
-    "url": "https://github.com/almadar-io/almadar.git",
+    "url": "https://github.com/almadar-io/orb.git",
     "directory": "cli/npm"
   },
   "homepage": "https://orb.almadar.io",
   "bugs": {
-    "url": "https://github.com/almadar-io/almadar/issues"
+    "url": "https://github.com/almadar-io/orb/issues"
   },
   "keywords": [
     "orb",
@@ -49,10 +49,10 @@
     "node": ">=16.0.0"
   },
   "optionalDependencies": {
-    "@almadar/orb-darwin-x64": "4.3.0",
-    "@almadar/orb-darwin-arm64": "4.3.0",
-    "@almadar/orb-linux-x64": "4.3.0",
-    "@almadar/orb-linux-arm64": "4.3.0",
-    "@almadar/orb-windows-x64": "4.3.0"
+    "@almadar/orb-darwin-x64": "4.7.0",
+    "@almadar/orb-darwin-arm64": "4.7.0",
+    "@almadar/orb-linux-x64": "4.7.0",
+    "@almadar/orb-linux-arm64": "4.7.0",
+    "@almadar/orb-windows-x64": "4.7.0"
   }
 }

package/scripts/postinstall.js

@@ -7,35 +7,45 @@ const platform = process.platform;
 const arch = process.arch;
 
 const platformMap = {
-  'darwin-x64': '@almadar/cli-darwin-x64',
-  'darwin-arm64': '@almadar/cli-darwin-arm64',
-  'linux-x64': '@almadar/cli-linux-x64',
-  'linux-arm64': '@almadar/cli-linux-arm64',
-  'win32-x64': '@almadar/cli-windows-x64',
+  'darwin-x64': '@almadar/orb-darwin-x64',
+  'darwin-arm64': '@almadar/orb-darwin-arm64',
+  'linux-x64': '@almadar/orb-linux-x64',
+  'linux-arm64': '@almadar/orb-linux-arm64',
+  'win32-x64': '@almadar/orb-windows-x64',
 };
 
 const key = `${platform}-${arch}`;
 const packageName = platformMap[key];
 
 if (!packageName) {
-  console.warn(`\n⚠️  Almadar CLI: No pre-built binary for ${platform}-${arch}`);
-  console.warn('   You can build from source: https://github.com/almadar-io/almadar#building-from-source\n');
+  console.warn(`\n  Orb CLI: No pre-built binary for ${platform}-${arch}`);
+  console.warn('  Build from source: https://github.com/almadar-io/orb#building-from-source\n');
   process.exit(0);
 }
 
-// Check if the platform-specific package was installed
 const possiblePaths = [
   path.join(__dirname, '..', 'node_modules', packageName),
   path.join(__dirname, '..', '..', packageName),
   path.join(__dirname, '..', '..', '..', packageName),
 ];
 
-const found = possiblePaths.some(p => fs.existsSync(p));
+const platformDir = possiblePaths.find(p => fs.existsSync(p));
 
-if (found) {
-  console.log(`✅ Almadar CLI installed for ${platform}-${arch}`);
-} else {
-  console.warn(`\n⚠️  Almadar CLI: Platform package ${packageName} not found`);
-  console.warn('   This may happen if optional dependencies were skipped.');
-  console.warn('   Try: npm install -g @almadar/cli --include=optional\n');
+if (!platformDir) {
+  console.warn(`\n  Orb CLI: Platform package ${packageName} not found`);
+  console.warn('  Try: npm install -g @almadar/orb --include=optional\n');
+  process.exit(0);
 }
+
+// Verify components
+const binaryName = platform === 'win32' ? 'orb.exe' : 'orb';
+const bunName = platform === 'win32' ? 'bun.exe' : 'bun';
+
+const hasBinary = fs.existsSync(path.join(platformDir, binaryName));
+const hasBun = fs.existsSync(path.join(platformDir, bunName));
+const hasAgent = fs.existsSync(path.join(platformDir, 'agent', 'cli.js'));
+
+console.log(`Orb CLI installed for ${platform}-${arch}:`);
+console.log(`  Binary:  ${hasBinary ? 'ok' : 'missing'}`);
+console.log(`  Bun:     ${hasBun ? 'ok' : 'not bundled (agent features require bun on PATH)'}`);
+console.log(`  Agent:   ${hasAgent ? 'ok' : 'not bundled (agent features unavailable)'}`);

package/shells/almadar-shell/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@almadar/shell",
-  "version": "2.5.0",
+  "version": "2.107.0",
   "private": false,
   "description": "Minimal full-stack shell template for Almadar applications",
   "packageManager": "pnpm@10.30.3",
@@ -9,6 +9,7 @@
     "build": "pnpm run -r build",
     "typecheck": "turbo run typecheck",
     "lint": "turbo run lint",
+    "prepack": "node -e \"const fs=require('fs');if(fs.existsSync('packages'))for(const p of fs.readdirSync('packages'))for(const j of ['.turbo','package-lock.json']){const t='packages/'+p+'/'+j;if(fs.existsSync(t))fs.rmSync(t,{recursive:true,force:true});}\"",
     "prepare": "git rev-parse --git-dir > /dev/null 2>&1 && git config core.hooksPath .githooks || true"
   },
   "devDependencies": {
@@ -19,11 +20,24 @@
     "overrides": {
       "@tootallnate/once": "^3.0.1",
       "esbuild": "^0.25.0",
-      "flatted": "^3.4.1"
+      "flatted": "^3.4.1",
+      "protobufjs": ">=7.5.8 <8",
+      "node-forge": "^1.4.0",
+      "fast-xml-parser": "^5.7.0",
+      "fast-xml-builder": ">=1.1.7",
+      "express>path-to-regexp": "0.1.13",
+      "qs": "^6.15.2",
+      "lodash-es": "^4.18.0"
     }
   },
   "files": [
-    "dist"
+    "packages",
+    "locales",
+    "pnpm-workspace.yaml",
+    "turbo.json",
+    "pnpm-lock.yaml",
+    ".env.example",
+    ".gitignore"
   ],
   "repository": {
     "type": "git",

package/shells/almadar-shell/packages/client/eslint.config.cjs

@@ -1,11 +1,31 @@
 "use strict";
 const tsParser = require("@typescript-eslint/parser");
 const almadarPlugin = require("@almadar/eslint-plugin");
+// react-hooks plugin registered so the codegen-emitted
+// `// eslint-disable-next-line react-hooks/exhaustive-deps` comments are
+// well-formed (eslint errors on disable directives that reference
+// unknown rules). The actual rules are left off — enabling them would
+// surface a backlog of dep-array warnings the codegen knows are
+// intentional. Tightening is a separate codegen-fix pass.
+let reactHooksPlugin;
+try {
+  reactHooksPlugin = require("eslint-plugin-react-hooks");
+} catch (_) {
+  reactHooksPlugin = { rules: { "exhaustive-deps": { meta: {}, create: () => ({}) }, "rules-of-hooks": { meta: {}, create: () => ({}) } } };
+}
 
 module.exports = [
   { ignores: ["dist/**", "node_modules/**", "**/*.test.ts", "**/*.test.tsx"] },
   {
     files: ["src/**/*.ts", "src/**/*.tsx"],
+    // The codegen emits `// eslint-disable-next-line react-hooks/exhaustive-deps`
+    // ahead of every mount-only effect's `[]` dep array. Until the real
+    // `eslint-plugin-react-hooks` is wired (it would fire the rule and
+    // make these directives meaningful), the shim's no-op create() means
+    // the rule never reports — so ESLint flags the directives as
+    // "Unused eslint-disable directive". That's a false alarm at this
+    // stage; suppress it so the strict-error rule set still hard-fails.
+    linterOptions: { reportUnusedDisableDirectives: "off" },
     languageOptions: {
       parser: tsParser,
       parserOptions: {
@@ -14,9 +34,22 @@ module.exports = [
         sourceType: "module",
       },
     },
-    plugins: { almadar: almadarPlugin },
+    plugins: { almadar: almadarPlugin, "react-hooks": reactHooksPlugin },
     rules: {
+      // Zero escape hatches in emitted shell code. Each rule pairs with a
+      // codegen-template fix in orbital-rust (see docs/Almadar_Compiler_Gaps.md):
+      // - no-as-any:           catches `as any` casts.
+      // - no-unknown-type:     catches `: unknown` annotations.
+      //                        Service results are typed via the integrations
+      //                        contract; every other "unknown" is a typed
+      //                        shape the codegen knows.
+      // - no-record-string-unknown: catches `as Record<string, unknown>` casts
+      //                        the codegen used to index into entity rows by
+      //                        string key. The entity has a typed interface
+      //                        — emit against that.
       "almadar/no-as-any": "error",
+      "almadar/no-unknown-type": "error",
+      "almadar/no-record-string-unknown": "error",
       "almadar/no-import-generated": "error",
     },
   },

package/shells/almadar-shell/packages/client/package.json

@@ -1,59 +1,61 @@
 {
   "name": "@almadar/shell-client",
-  "version": "1.0.0",
+  "version": "2.13.15",
   "private": true,
   "type": "module",
   "scripts": {
     "dev": "vite",
     "build": "tsc && vite build",
     "typecheck": "tsc --noEmit",
-    "lint": "eslint src/",
+    "lint": "eslint --max-warnings 0 src/",
     "preview": "vite preview",
     "test": "vitest run --passWithNoTests",
     "test:watch": "vitest"
   },
   "dependencies": {
-    "@almadar/ui": ">=2.34.1",
-    "@almadar/syntax": ">=1.1.0",
-    "@almadar/evaluator": ">=2.6.0",
-    "@almadar/patterns": ">=2.8.12",
-    "@almadar/core": ">=2.9.0",
-    "firebase": "^11.4.0",
+    "@almadar/core": "^10.92.0",
+    "@almadar/evaluator": "^2.45.0",
+    "@almadar/logger": "^1.12.0",
+    "@almadar/patterns": "^2.101.0",
+    "@almadar/syntax": "^1.17.0",
+    "@almadar/ui": "^6.19.0",
+    "@monaco-editor/react": "^4.7.0",
+    "@react-three/drei": "^9.92.0",
+    "@react-three/fiber": "^9.0.0",
+    "@react-three/postprocessing": "^3.0.0",
     "@tanstack/react-query": "^5.67.3",
+    "firebase": "^11.4.0",
+    "leaflet": "^1.9.4",
+    "lucide-react": "^0.344.0",
+    "monaco-editor": "^0.52.2",
+    "postprocessing": "^6.39.0",
     "react": "^19.0.0",
     "react-dom": "^19.0.0",
-    "react-router-dom": "^7.3.0",
-    "zustand": "^5.0.3",
+    "react-force-graph-2d": "^1.25.5",
+    "react-leaflet": "^4.2.1",
     "react-markdown": "^9.0.1",
-    "remark-gfm": "^4.0.1",
-    "remark-math": "^6.0.0",
+    "react-router-dom": "^7.3.0",
     "rehype-katex": "^7.0.1",
     "rehype-raw": "^7.0.0",
-    "react-force-graph-2d": "^1.25.5",
-    "@monaco-editor/react": "^4.7.0",
-    "monaco-editor": "^0.52.2",
-    "leaflet": "^1.9.4",
-    "react-leaflet": "^4.2.1",
-    "lucide-react": "^0.344.0",
+    "remark-gfm": "^4.0.1",
+    "remark-math": "^6.0.0",
     "three": "^0.160.0",
-    "@react-three/fiber": "^9.0.0",
-    "@react-three/drei": "^9.92.0",
-    "@react-three/postprocessing": "^3.0.0",
-    "postprocessing": "^6.39.0"
+    "zustand": "^5.0.3"
   },
   "devDependencies": {
-    "@almadar/eslint-plugin": ">=2.3.0",
-    "@typescript-eslint/parser": "8.56.0",
-    "eslint": "10.0.0",
-    "@testing-library/react": "^16.1.0",
+    "@almadar/eslint-plugin": "^2.18.0",
     "@testing-library/jest-dom": "^6.6.3",
+    "@testing-library/react": "^16.1.0",
     "@types/react": "^19.0.0",
     "@types/react-dom": "^19.0.0",
+    "@typescript-eslint/parser": "8.56.0",
     "@vitejs/plugin-react": "^4.3.4",
     "autoprefixer": "^10.4.20",
+    "eslint": "10.0.0",
     "jsdom": "^25.0.1",
     "postcss": "^8.5.3",
     "tailwindcss": "^3.4.17",
+    "@tailwindcss/container-queries": "^0.1.1",
     "typescript": "^5.7.3",
     "vite": "^6.2.1",
     "vitest": "^2.1.9"

package/shells/almadar-shell/packages/client/src/App.tsx

@@ -11,15 +11,19 @@
  * - react-router is optional for URL bookmarkability
  */
 
+import React from 'react';
 import { BrowserRouter, Routes, Route } from 'react-router-dom';
 import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
 import { ThemeProvider, UISlotProvider } from '@almadar/ui/context';
-import { UISlotComponent, NotifyListener } from '@almadar/ui/components';
+import { UISlotComponent } from '@almadar/ui/components';
 import {
-  EntityStoreProvider,
   EventBusProvider,
+  UserProvider,
   VerificationProvider,
 } from '@almadar/ui/providers';
+import { normalizeUserContext } from '@almadar/core';
+import { AuthProvider, useAuthContext } from './features/auth';
+import { PersonaSwitcher } from './features/auth/components/PersonaSwitcher';
 import { NavigationProvider } from '@almadar/ui/renderer';
 import { I18nProvider, createTranslate } from '@almadar/ui/hooks';
 import defaultLocale from '@almadar/ui/locales/en.json';
@@ -44,12 +48,25 @@ const queryClient = new QueryClient({
   },
 });
 
+/**
+ * Bridges the signed-in viewer into `UserProvider`. Generated trait hooks read
+ * `@user.x` through `useUser()`, so without this every role gate takes its
+ * negative branch and every "only mine" list renders empty — with no error, since
+ * `useUser()` falls back to anonymous. `normalizeUserContext` maps the provider's
+ * `uid`/`displayName` onto the `id`/`name` the behaviors read.
+ */
+function ViewerProvider({ children }: { children: React.ReactNode }) {
+  const { user } = useAuthContext();
+  return <UserProvider user={normalizeUserContext(user) ?? null}>{children}</UserProvider>;
+}
+
 function App() {
   return (
     <I18nProvider value={i18nValue}>
     <QueryClientProvider client={queryClient}>
-      <ThemeProvider>
-        <EntityStoreProvider>
+      <ThemeProvider defaultTheme="minimalist">
+       <AuthProvider>
+        <ViewerProvider>
         <EventBusProvider>
           <VerificationProvider>
             <UISlotProvider>
@@ -68,13 +85,14 @@ function App() {
                   {/* Portal slots rendered by compiled trait views via CompiledPortal */}
                   {/* Toast notifications (non-overlapping, always safe to render here) */}
                   <UISlotComponent slot="toast" portal />
-                  <NotifyListener />
+                  <PersonaSwitcher />
                 </BrowserRouter>
               </NavigationProvider>
             </UISlotProvider>
           </VerificationProvider>
         </EventBusProvider>
-        </EntityStoreProvider>
+        </ViewerProvider>
+       </AuthProvider>
       </ThemeProvider>
     </QueryClientProvider>
     </I18nProvider>

package/shells/almadar-shell/packages/client/src/config/firebase.ts

@@ -1,8 +1,8 @@
 import { initializeApp, getApps, getApp, FirebaseApp } from 'firebase/app';
 import { getAuth, Auth } from 'firebase/auth';
 
-let app: FirebaseApp;
-let auth: Auth;
+let app: FirebaseApp | undefined;
+let auth: Auth | undefined;
 
 export async function initializeFirebase(): Promise<void> {
   if (getApps().length > 0) {
@@ -30,8 +30,29 @@ export async function initializeFirebase(): Promise<void> {
     };
   }
 
+  // No credentials anywhere — auth stays disabled instead of crashing
+  // the app boot with auth/invalid-api-key.
+  if (!config.apiKey) {
+    console.warn('Firebase not configured — auth disabled (set VITE_APP_FIREBASE_* env vars)');
+    return;
+  }
+
   app = initializeApp(config);
   auth = getAuth(app);
 }
 
+export function requireAuth(): Auth {
+  if (!auth) {
+    throw new Error('Firebase auth is not configured — set VITE_APP_FIREBASE_* env vars');
+  }
+  return auth;
+}
+
+// True once Firebase initialized with real credentials. When false the
+// app runs in auth-disabled mode: route guards pass through and sign-in
+// actions report the missing config instead of crashing the boot.
+export function isAuthEnabled(): boolean {
+  return auth !== undefined;
+}
+
 export { auth, app };