@supacloud/app 0.4.0 → 0.5.0

package/dist/index.js

@@ -1,3 +1,14 @@
+var __legacyDecorateClassTS = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1;i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+
 // src/scope.ts
 var SCOPES = ["application", "request", "job"];
 var DEFAULT_SCOPE = "application";
@@ -13,16 +24,71 @@ function isScopeViolation(from, to) {
 class InjectionToken {
   name;
   factory;
+  providedIn;
   scope;
   constructor(name, options = {}) {
     this.name = name;
     this.factory = options.factory;
+    this.providedIn = options.providedIn;
     this.scope = options.scope;
   }
   toString() {
     return `InjectionToken ${this.name}`;
   }
 }
+// src/context.ts
+var REQUEST_CONTEXT = new InjectionToken("supacloud.request-context", {
+  scope: "request"
+});
+var JOB_CONTEXT = new InjectionToken("supacloud.job-context", {
+  scope: "job"
+});
+var DB_CLIENT = new InjectionToken("supacloud.db-client", {
+  scope: "application"
+});
+var APP_INITIALIZER = new InjectionToken("supacloud.app-initializer", { scope: "application" });
+var ENVIRONMENT_INITIALIZER = new InjectionToken("supacloud.environment-initializer", { scope: "application" });
+var DESTROY_REF = new InjectionToken("supacloud.destroy-ref", {
+  scope: "application",
+  factory: () => createDestroyRef()
+});
+function createDestroyRef() {
+  let isDestroyed = false;
+  const abortController = new AbortController;
+  const callbacks = [];
+  return {
+    get destroyed() {
+      return isDestroyed;
+    },
+    get signal() {
+      return abortController.signal;
+    },
+    onDestroy(callback) {
+      if (isDestroyed) {
+        throw new Error("Cannot register onDestroy callback on an already destroyed DestroyRef");
+      }
+      callbacks.push(callback);
+      return () => {
+        const idx = callbacks.indexOf(callback);
+        if (idx !== -1)
+          callbacks.splice(idx, 1);
+      };
+    },
+    async destroy() {
+      if (isDestroyed)
+        return;
+      isDestroyed = true;
+      abortController.abort();
+      const reversed = [...callbacks].reverse();
+      callbacks.length = 0;
+      for (const cb of reversed) {
+        await cb();
+      }
+    },
+    _teardowns: callbacks
+  };
+}
+
 // src/provider.ts
 function isClassProvider(provider) {
   return typeof provider === "object" && provider !== null && "useClass" in provider;
@@ -36,6 +102,49 @@ function isFactoryProvider(provider) {
 function isExistingProvider(provider) {
   return typeof provider === "object" && provider !== null && "useExisting" in provider;
 }
+function makeEnvironmentProviders(providers) {
+  return { ɵproviders: providers };
+}
+function isEnvironmentProviders(value) {
+  return typeof value === "object" && value !== null && "ɵproviders" in value && Array.isArray(value.ɵproviders);
+}
+function flattenProviders(providers) {
+  const result = [];
+  for (const p of providers) {
+    if (isEnvironmentProviders(p)) {
+      result.push(...p.ɵproviders);
+    } else {
+      result.push(p);
+    }
+  }
+  return result;
+}
+function provideAppInitializer(initializerFn) {
+  return makeEnvironmentProviders([
+    {
+      provide: APP_INITIALIZER,
+      useValue: initializerFn,
+      multi: true
+    }
+  ]);
+}
+function provideEnvironmentInitializer(initializerFn) {
+  return makeEnvironmentProviders([
+    {
+      provide: ENVIRONMENT_INITIALIZER,
+      useValue: initializerFn,
+      multi: true
+    }
+  ]);
+}
+function provideToken(token, value) {
+  return makeEnvironmentProviders([
+    {
+      provide: token,
+      useValue: value
+    }
+  ]);
+}
 // src/decorators.ts
 var INJECTABLE_METADATA = "supacloud:injectable";
 var MODULE_METADATA = "supacloud:module";
@@ -44,6 +153,16 @@ var QUERY_METADATA = "supacloud:query";
 var CONTROLLER_METADATA = "supacloud:controller";
 var ROUTES_METADATA = "supacloud:routes";
 var INJECT_PARAMS_METADATA = "supacloud:inject-params";
+var OPTIONAL_PARAMS_METADATA = "supacloud:optional-params";
+var SELF_PARAMS_METADATA = "supacloud:self-params";
+var SKIP_SELF_PARAMS_METADATA = "supacloud:skip-self-params";
+var HOST_PARAMS_METADATA = "supacloud:host-params";
+var GUARDS_METADATA = "supacloud:guards";
+var CAN_DEACTIVATE_METADATA = "supacloud:guards:can-deactivate";
+var RESOLVE_METADATA = "supacloud:resolvers";
+var TITLE_METADATA = "supacloud:route:title";
+var DATA_METADATA = "supacloud:route:data";
+var ROUTE_PARAMS_METADATA = "supacloud:route-params";
 function defineMetadata(target, key, value) {
   Object.defineProperty(target, key, {
     value,
@@ -58,6 +177,7 @@ function Injectable(options = {}) {
   return (target) => {
     const meta = {
       scope: options.scope ?? DEFAULT_SCOPE,
+      providedIn: options.providedIn,
       deps: options.deps ?? []
     };
     defineMetadata(target, INJECTABLE_METADATA, meta);
@@ -82,13 +202,94 @@ function Inject(token) {
 function getInjectParams(target) {
   return readOwnOrInherited(target, INJECT_PARAMS_METADATA) ?? {};
 }
+function Optional() {
+  return (target, propertyKey, parameterIndex) => {
+    if (propertyKey !== undefined) {
+      throw new Error("@Optional() is only supported on constructor parameters");
+    }
+    const cls = target;
+    const list = [...readOwnOrInherited(cls, OPTIONAL_PARAMS_METADATA) ?? []];
+    if (!list.includes(parameterIndex))
+      list.push(parameterIndex);
+    defineMetadata(cls, OPTIONAL_PARAMS_METADATA, list);
+  };
+}
+function getOptionalParams(target) {
+  return readOwnOrInherited(target, OPTIONAL_PARAMS_METADATA) ?? [];
+}
+function Self() {
+  return (target, propertyKey, parameterIndex) => {
+    if (propertyKey !== undefined) {
+      throw new Error("@Self() is only supported on constructor parameters");
+    }
+    const cls = target;
+    const list = [...readOwnOrInherited(cls, SELF_PARAMS_METADATA) ?? []];
+    if (!list.includes(parameterIndex))
+      list.push(parameterIndex);
+    defineMetadata(cls, SELF_PARAMS_METADATA, list);
+  };
+}
+function getSelfParams(target) {
+  return readOwnOrInherited(target, SELF_PARAMS_METADATA) ?? [];
+}
+function SkipSelf() {
+  return (target, propertyKey, parameterIndex) => {
+    if (propertyKey !== undefined) {
+      throw new Error("@SkipSelf() is only supported on constructor parameters");
+    }
+    const cls = target;
+    const list = [...readOwnOrInherited(cls, SKIP_SELF_PARAMS_METADATA) ?? []];
+    if (!list.includes(parameterIndex))
+      list.push(parameterIndex);
+    defineMetadata(cls, SKIP_SELF_PARAMS_METADATA, list);
+  };
+}
+function getSkipSelfParams(target) {
+  return readOwnOrInherited(target, SKIP_SELF_PARAMS_METADATA) ?? [];
+}
+function Host() {
+  return (target, propertyKey, parameterIndex) => {
+    if (propertyKey !== undefined) {
+      throw new Error("@Host() is only supported on constructor parameters");
+    }
+    const cls = target;
+    const list = [...readOwnOrInherited(cls, HOST_PARAMS_METADATA) ?? []];
+    if (!list.includes(parameterIndex))
+      list.push(parameterIndex);
+    defineMetadata(cls, HOST_PARAMS_METADATA, list);
+  };
+}
+function getHostParams(target) {
+  return readOwnOrInherited(target, HOST_PARAMS_METADATA) ?? [];
+}
+function UseGuards(...guards) {
+  return (target, propertyKey) => {
+    if (propertyKey !== undefined) {
+      const cls = target.constructor;
+      const key = `${GUARDS_METADATA}:${String(propertyKey)}`;
+      const existing = readOwnOrInherited(cls, key) ?? [];
+      defineMetadata(cls, key, [...existing, ...guards]);
+    } else {
+      const existing = readOwnOrInherited(target, GUARDS_METADATA) ?? [];
+      defineMetadata(target, GUARDS_METADATA, [...existing, ...guards]);
+    }
+  };
+}
+function getGuards(target, propertyKey) {
+  if (propertyKey !== undefined) {
+    const methodGuards = readOwnOrInherited(target, `${GUARDS_METADATA}:${String(propertyKey)}`) ?? [];
+    const classGuards = readOwnOrInherited(target, GUARDS_METADATA) ?? [];
+    return [...classGuards, ...methodGuards];
+  }
+  return readOwnOrInherited(target, GUARDS_METADATA) ?? [];
+}
 function Module(options) {
   return (target) => {
     const meta = {
       name: options.name,
       tags: options.tags ?? [],
       imports: options.imports ?? [],
-      providers: options.providers ?? [],
+      providers: options.providers ? flattenProviders(options.providers) : [],
       controllers: options.controllers ?? [],
       commands: options.commands ?? [],
       queries: options.queries ?? [],
@@ -112,17 +313,69 @@ function Command(options) {
 function getCommandMeta(target) {
   return readOwnOrInherited(target, COMMAND_METADATA);
 }
-function Query(options) {
-  return (target) => {
-    defineMetadata(target, QUERY_METADATA, { ...options });
+function Param(nameOrOptions, options) {
+  return (target, propertyKey, parameterIndex) => {
+    if (propertyKey === undefined) {
+      throw new Error("@Param() is only supported on controller method parameters");
+    }
+    const cls = target.constructor;
+    const key = `${ROUTE_PARAMS_METADATA}:${String(propertyKey)}`;
+    const existing = readOwnOrInherited(cls, key) ?? [];
+    const name = typeof nameOrOptions === "string" ? nameOrOptions : nameOrOptions?.name;
+    const transform = typeof nameOrOptions === "object" ? nameOrOptions.transform : options?.transform;
+    const defaultValue = typeof nameOrOptions === "object" ? nameOrOptions.default : options?.default;
+    defineMetadata(cls, key, [...existing, { index: parameterIndex, type: "param", name, transform, default: defaultValue }]);
   };
 }
+function Body() {
+  return (target, propertyKey, parameterIndex) => {
+    if (propertyKey === undefined) {
+      throw new Error("@Body() is only supported on controller method parameters");
+    }
+    const cls = target.constructor;
+    const key = `${ROUTE_PARAMS_METADATA}:${String(propertyKey)}`;
+    const existing = readOwnOrInherited(cls, key) ?? [];
+    defineMetadata(cls, key, [...existing, { index: parameterIndex, type: "body" }]);
+  };
+}
+function Headers(name) {
+  return (target, propertyKey, parameterIndex) => {
+    if (propertyKey === undefined) {
+      throw new Error("@Headers() is only supported on controller method parameters");
+    }
+    const cls = target.constructor;
+    const key = `${ROUTE_PARAMS_METADATA}:${String(propertyKey)}`;
+    const existing = readOwnOrInherited(cls, key) ?? [];
+    defineMetadata(cls, key, [...existing, { index: parameterIndex, type: "headers", name }]);
+  };
+}
+function Query(optionsOrName, options) {
+  return (target, propertyKey, parameterIndex) => {
+    if (typeof parameterIndex === "number" && propertyKey !== undefined) {
+      const cls = target.constructor;
+      const key = `${ROUTE_PARAMS_METADATA}:${String(propertyKey)}`;
+      const existing = readOwnOrInherited(cls, key) ?? [];
+      const name = typeof optionsOrName === "string" ? optionsOrName : optionsOrName?.name;
+      const transform = typeof optionsOrName === "object" ? optionsOrName.transform : options?.transform;
+      const defaultValue = typeof optionsOrName === "object" ? optionsOrName.default : options?.default;
+      defineMetadata(cls, key, [...existing, { index: parameterIndex, type: "query", name, transform, default: defaultValue }]);
+    } else {
+      const opts = typeof optionsOrName === "object" && optionsOrName !== null ? optionsOrName : { name: String(optionsOrName ?? "") };
+      defineMetadata(target, QUERY_METADATA, { ...opts });
+    }
+  };
+}
+function getRouteParams(target, propertyKey) {
+  const params = readOwnOrInherited(target, `${ROUTE_PARAMS_METADATA}:${String(propertyKey)}`) ?? [];
+  return [...params].sort((a, b) => a.index - b.index);
+}
 function getQueryMeta(target) {
   return readOwnOrInherited(target, QUERY_METADATA);
 }
-function Controller(path) {
+function Controller(pathOrOptions = "/") {
   return (target) => {
-    defineMetadata(target, CONTROLLER_METADATA, { path });
+    const meta = typeof pathOrOptions === "string" ? { path: pathOrOptions } : { path: pathOrOptions.path ?? "/", standalone: pathOrOptions.standalone };
+    defineMetadata(target, CONTROLLER_METADATA, meta);
   };
 }
 function getControllerMeta(target) {
@@ -131,6 +384,23 @@ function getControllerMeta(target) {
 function createRouteDecorator(method) {
   return (path, options = {}) => (target, propertyKey) => {
     const cls = target.constructor;
+    const titleKey = `${TITLE_METADATA}:${String(propertyKey)}`;
+    const dataKey = `${DATA_METADATA}:${String(propertyKey)}`;
+    const deactKey = `${CAN_DEACTIVATE_METADATA}:${String(propertyKey)}`;
+    const resolveKey = `${RESOLVE_METADATA}:${String(propertyKey)}`;
+    const title = options.title ?? readOwnOrInherited(cls, titleKey);
+    const data = {
+      ...readOwnOrInherited(cls, dataKey) ?? {},
+      ...options.data ?? {}
+    };
+    const canDeactivate = [
+      ...readOwnOrInherited(cls, deactKey) ?? [],
+      ...options.canDeactivate ?? []
+    ];
+    const resolvers = {
+      ...readOwnOrInherited(cls, resolveKey) ?? {},
+      ...options.resolvers ?? {}
+    };
     const routes = [
       ...readOwnOrInherited(cls, ROUTES_METADATA) ?? []
     ];
@@ -138,7 +408,11 @@ function createRouteDecorator(method) {
       method,
       path,
       handler: String(propertyKey),
-      ...options
+      ...options,
+      resolvers: Object.keys(resolvers).length > 0 ? resolvers : undefined,
+      canDeactivate: canDeactivate.length > 0 ? canDeactivate : undefined,
+      title: title || undefined,
+      data: Object.keys(data).length > 0 ? data : undefined
     });
     defineMetadata(cls, ROUTES_METADATA, routes);
   };
@@ -150,6 +424,68 @@ var Patch = createRouteDecorator("PATCH");
 var Delete = createRouteDecorator("DELETE");
 var Head = createRouteDecorator("HEAD");
 var Options = createRouteDecorator("OPTIONS");
+function Title(title) {
+  return (target, propertyKey) => {
+    const cls = target.constructor;
+    const key = `${TITLE_METADATA}:${String(propertyKey)}`;
+    defineMetadata(cls, key, title);
+    const routes = readOwnOrInherited(cls, ROUTES_METADATA) ?? [];
+    const route = routes.find((r) => r.handler === String(propertyKey));
+    if (route) {
+      route.title = title;
+    }
+  };
+}
+function Data(data) {
+  return (target, propertyKey) => {
+    const cls = target.constructor;
+    const key = `${DATA_METADATA}:${String(propertyKey)}`;
+    const existing = readOwnOrInherited(cls, key) ?? {};
+    defineMetadata(cls, key, { ...existing, ...data });
+    const routes = readOwnOrInherited(cls, ROUTES_METADATA) ?? [];
+    const route = routes.find((r) => r.handler === String(propertyKey));
+    if (route) {
+      route.data = { ...route.data, ...data };
+    }
+  };
+}
+function CanDeactivate(...guards) {
+  return (target, propertyKey) => {
+    const cls = target.constructor;
+    const key = `${CAN_DEACTIVATE_METADATA}:${String(propertyKey)}`;
+    const existing = readOwnOrInherited(cls, key) ?? [];
+    defineMetadata(cls, key, [...existing, ...guards]);
+    const routes = readOwnOrInherited(cls, ROUTES_METADATA) ?? [];
+    const route = routes.find((r) => r.handler === String(propertyKey));
+    if (route) {
+      route.canDeactivate = [...route.canDeactivate ?? [], ...guards];
+    }
+  };
+}
+function Resolve(resolvers) {
+  return (target, propertyKey) => {
+    const cls = target.constructor;
+    const key = `${RESOLVE_METADATA}:${String(propertyKey)}`;
+    const existing = readOwnOrInherited(cls, key) ?? {};
+    defineMetadata(cls, key, { ...existing, ...resolvers });
+    const routes = readOwnOrInherited(cls, ROUTES_METADATA) ?? [];
+    const route = routes.find((r) => r.handler === String(propertyKey));
+    if (route) {
+      route.resolvers = { ...route.resolvers ?? {}, ...resolvers };
+    }
+  };
+}
+async function executeResolvers(resolvers, ctx) {
+  const entries = Object.entries(resolvers);
+  const resolved = await Promise.all(entries.map(async ([key, resolver]) => {
+    if (typeof resolver === "function") {
+      const val = await resolver(ctx);
+      return [key, val];
+    }
+    return [key, resolver];
+  }));
+  return Object.fromEntries(resolved);
+}
 function getRoutes(target) {
   return readOwnOrInherited(target, ROUTES_METADATA) ?? [];
 }
@@ -164,55 +500,2349 @@ function defineModule(options) {
   Module(options)(DefinedModule);
   return DefinedModule;
 }
-// src/context.ts
-var REQUEST_CONTEXT = new InjectionToken("supacloud.request-context", {
-  scope: "request"
+// src/forward_ref.ts
+function forwardRef(fn) {
+  fn.__forward_ref__ = forwardRef;
+  return fn;
+}
+function resolveForwardRef(type) {
+  if (isForwardRef(type)) {
+    return type();
+  }
+  return type;
+}
+function isForwardRef(fn) {
+  return typeof fn === "function" && fn.__forward_ref__ === forwardRef;
+}
+
+// src/inject.ts
+var currentInjector = null;
+function getActiveInjector() {
+  return currentInjector;
+}
+var INJECTOR = new InjectionToken("supacloud.injector", {
+  scope: "application",
+  factory: () => {
+    const active = getActiveInjector();
+    if (!active) {
+      throw new Error("Cannot resolve INJECTOR outside of an active injection context.");
+    }
+    return active;
+  }
 });
-var JOB_CONTEXT = new InjectionToken("supacloud.job-context", {
-  scope: "job"
+function runInInjectionContext(injector, fn) {
+  const prev = currentInjector;
+  currentInjector = injector;
+  try {
+    return fn();
+  } finally {
+    currentInjector = prev;
+  }
+}
+function inject(token, options) {
+  if (!currentInjector) {
+    throw new Error(`inject() can only be used within an active injection context (constructor, factory, guard, or runInInjectionContext). Token: ${tokenToString(token)}`);
+  }
+  const resolved = resolveForwardRef(token);
+  let value;
+  if (options?.skipSelf) {
+    if (!currentInjector.parent) {
+      if (options.optional)
+        return;
+      throw new Error(`NullInjectorError: No parent provider found for skipSelf token ${tokenToString(resolved)}`);
+    }
+    value = currentInjector.parent.get(resolved, options);
+  } else {
+    value = currentInjector.get(resolved, options);
+  }
+  if (value === undefined) {
+    if (options?.optional) {
+      return;
+    }
+    if (resolved instanceof InjectionToken && resolved.factory && !options?.self && !options?.skipSelf) {
+      return resolved.factory();
+    }
+    throw new Error(`NullInjectorError: No provider for ${tokenToString(resolved)}`);
+  }
+  return value;
+}
+function injectAll(token) {
+  const value = inject(token, { optional: true });
+  if (value === undefined)
+    return [];
+  return Array.isArray(value) ? value : [value];
+}
+function createChildInjector(parent, localProviders = new Map) {
+  const providerMap = localProviders instanceof Map ? localProviders : new Map(Object.entries(localProviders));
+  return {
+    parent,
+    get(token, options) {
+      const resolved = resolveForwardRef(token);
+      if (providerMap.has(resolved)) {
+        return providerMap.get(resolved);
+      }
+      if (resolved instanceof InjectionToken && providerMap.has(resolved.name)) {
+        return providerMap.get(resolved.name);
+      }
+      if (options?.self) {
+        return;
+      }
+      return parent.get(resolved);
+    }
+  };
+}
+function assertInInjectionContext(fnName) {
+  if (!currentInjector) {
+    throw new Error(`${fnName} must be called from an active injection context.`);
+  }
+}
+function injectDestroySignal() {
+  const ref = inject(DESTROY_REF);
+  if (ref.signal)
+    return ref.signal;
+  throw new Error("Active DestroyRef does not provide an AbortSignal");
+}
+function tokenToString(token) {
+  if (typeof token === "string")
+    return token;
+  if (token instanceof InjectionToken)
+    return token.toString();
+  if (typeof token === "function")
+    return token.name || "AnonymousClass";
+  return String(token);
+}
+function createEnvironmentInjector(providers, parent) {
+  let isDestroyed = false;
+  const flatProviders = flattenProviders(providers);
+  const effectiveProviders = new Map;
+  const multiProviders = new Map;
+  const instances = new Map;
+  const localDestroyRef = createDestroyRef();
+  instances.set(DESTROY_REF, localDestroyRef);
+  for (const p of flatProviders) {
+    const token = typeof p === "function" ? resolveForwardRef(p) : resolveForwardRef(p.provide);
+    if (typeof p !== "function" && p.multi) {
+      const list = multiProviders.get(token) ?? [];
+      list.push(p);
+      multiProviders.set(token, list);
+    } else {
+      effectiveProviders.set(token, p);
+    }
+  }
+  const injector = {
+    parent,
+    get destroyed() {
+      return isDestroyed;
+    },
+    runInContext(fn) {
+      if (isDestroyed) {
+        throw new Error("EnvironmentInjector has already been destroyed.");
+      }
+      return runInInjectionContext(injector, fn);
+    },
+    destroy() {
+      if (isDestroyed)
+        return;
+      isDestroyed = true;
+      localDestroyRef.destroy();
+      for (const inst of instances.values()) {
+        if (inst && typeof inst === "object" && inst !== localDestroyRef) {
+          if ("onDestroy" in inst && typeof inst.onDestroy === "function") {
+            try {
+              inst.onDestroy();
+            } catch (err) {
+              console.error("Error in onDestroy hook:", err);
+            }
+          }
+          if ("ngOnDestroy" in inst && typeof inst.ngOnDestroy === "function") {
+            try {
+              inst.ngOnDestroy();
+            } catch (err) {
+              console.error("Error in ngOnDestroy hook:", err);
+            }
+          }
+        }
+      }
+      instances.clear();
+    },
+    get(token, notFoundOrOptions, maybeOptions) {
+      if (isDestroyed) {
+        throw new Error("EnvironmentInjector has already been destroyed.");
+      }
+      let notFoundValue = undefined;
+      let flags = undefined;
+      if (notFoundOrOptions !== undefined && (typeof notFoundOrOptions !== "object" || notFoundOrOptions === null || !("optional" in notFoundOrOptions) && !("skipSelf" in notFoundOrOptions) && !("self" in notFoundOrOptions) && !("host" in notFoundOrOptions))) {
+        notFoundValue = notFoundOrOptions;
+        flags = maybeOptions;
+      } else if (notFoundOrOptions && typeof notFoundOrOptions === "object") {
+        flags = notFoundOrOptions;
+      }
+      const resolved = resolveForwardRef(token);
+      if (flags?.skipSelf) {
+        if (!parent) {
+          if (flags.optional)
+            return;
+          if (notFoundValue !== undefined)
+            return notFoundValue;
+          throw new Error(`NullInjectorError: No parent provider found for skipSelf token ${tokenToString(resolved)}`);
+        }
+        const val = parent.get(resolved, flags);
+        if (val === undefined && notFoundValue !== undefined)
+          return notFoundValue;
+        return val;
+      }
+      if (instances.has(resolved)) {
+        return instances.get(resolved);
+      }
+      if (resolved instanceof InjectionToken && instances.has(resolved.name)) {
+        return instances.get(resolved.name);
+      }
+      if (multiProviders.has(resolved)) {
+        const provs = multiProviders.get(resolved);
+        const results = provs.map((prov) => {
+          if (isValueProvider(prov))
+            return prov.useValue;
+          if (isFactoryProvider(prov))
+            return runInInjectionContext(injector, () => prov.useFactory());
+          if (isClassProvider(prov))
+            return runInInjectionContext(injector, () => new prov.useClass);
+          if (isExistingProvider(prov))
+            return injector.get(prov.useExisting);
+          return;
+        });
+        instances.set(resolved, results);
+        if (resolved instanceof InjectionToken) {
+          instances.set(resolved.name, results);
+        }
+        return results;
+      }
+      const provider = effectiveProviders.get(resolved);
+      if (!provider) {
+        if (flags?.self) {
+          if (flags.optional)
+            return;
+          if (notFoundValue !== undefined)
+            return notFoundValue;
+          throw new Error(`NullInjectorError: No local provider for ${tokenToString(resolved)}`);
+        }
+        if (parent) {
+          const fromParent = parent.get(resolved, flags);
+          if (fromParent !== undefined)
+            return fromParent;
+        }
+        if (flags?.optional)
+          return;
+        if (notFoundValue !== undefined)
+          return notFoundValue;
+        if (resolved instanceof InjectionToken && resolved.factory && !flags?.self && !flags?.skipSelf) {
+          const inst = resolved.factory();
+          instances.set(resolved, inst);
+          return inst;
+        }
+        if (typeof resolved === "function") {
+          try {
+            const inst = new resolved;
+            instances.set(resolved, inst);
+            return inst;
+          } catch {}
+        }
+        throw new Error(`NullInjectorError: No provider for ${tokenToString(resolved)}`);
+      }
+      let created;
+      if (typeof provider === "function") {
+        created = runInInjectionContext(injector, () => new provider);
+      } else if (isValueProvider(provider)) {
+        created = provider.useValue;
+      } else if (isFactoryProvider(provider)) {
+        created = runInInjectionContext(injector, () => provider.useFactory());
+      } else if (isClassProvider(provider)) {
+        created = runInInjectionContext(injector, () => new provider.useClass);
+      } else if (isExistingProvider(provider)) {
+        created = injector.get(provider.useExisting);
+      }
+      instances.set(resolved, created);
+      return created;
+    }
+  };
+  instances.set(INJECTOR, injector);
+  const envInitializers = injector.get(ENVIRONMENT_INITIALIZER, { optional: true });
+  const seenInits = new Set;
+  if (Array.isArray(envInitializers)) {
+    for (const init of envInitializers) {
+      if (typeof init === "function") {
+        seenInits.add(init);
+        runInInjectionContext(injector, () => {
+          init();
+        });
+      }
+    }
+  }
+  const appInitializers = injector.get(APP_INITIALIZER, { optional: true });
+  if (Array.isArray(appInitializers)) {
+    for (const init of appInitializers) {
+      if (typeof init === "function" && !seenInits.has(init)) {
+        seenInits.add(init);
+        runInInjectionContext(injector, () => {
+          init();
+        });
+      }
+    }
+  }
+  return injector;
+}
+// src/route_match.ts
+function matchRoute(pattern, url, strategy = "full") {
+  const patternSegments = pattern.replace(/^\/+|\/+$/g, "").split("/").filter(Boolean);
+  const cleanUrl = url.split("?")[0].replace(/^\/+|\/+$/g, "");
+  const urlSegments = cleanUrl.split("/").filter(Boolean);
+  if (strategy === "full" && patternSegments.length !== urlSegments.length) {
+    return { matched: false, params: {} };
+  }
+  if (strategy === "prefix" && urlSegments.length < patternSegments.length) {
+    return { matched: false, params: {} };
+  }
+  const params = {};
+  for (let i = 0;i < patternSegments.length; i += 1) {
+    const p = patternSegments[i];
+    const u = urlSegments[i];
+    if (p.startsWith(":")) {
+      const paramName = p.slice(1);
+      params[paramName] = decodeURIComponent(u);
+    } else if (p !== u) {
+      return { matched: false, params: {} };
+    }
+  }
+  const remainingSegments = urlSegments.slice(patternSegments.length);
+  const remainingUrl = remainingSegments.length > 0 ? `/${remainingSegments.join("/")}` : undefined;
+  return {
+    matched: true,
+    params,
+    remainingUrl
+  };
+}
+// src/interceptor.ts
+function withInterceptors(...interceptors) {
+  return interceptors.flat();
+}
+function createBearerAuthInterceptor(tokenOrGetter) {
+  return async (req, next) => {
+    const token = typeof tokenOrGetter === "function" ? await tokenOrGetter() : tokenOrGetter;
+    if (token) {
+      req.headers = {
+        ...req.headers,
+        authorization: `Bearer ${token}`
+      };
+    }
+    return next(req);
+  };
+}
+function createHeaderInterceptor(headers) {
+  return async (req, next) => {
+    const custom = typeof headers === "function" ? await headers() : headers;
+    req.headers = {
+      ...req.headers,
+      ...custom
+    };
+    return next(req);
+  };
+}
+function createTimeoutInterceptor(timeoutMs) {
+  return async (req, next) => {
+    let timer;
+    const timeoutPromise = new Promise((_, reject) => {
+      timer = setTimeout(() => {
+        reject(new Error(`HTTP request timed out after ${timeoutMs}ms: ${req.method} ${req.url}`));
+      }, timeoutMs);
+    });
+    try {
+      return await Promise.race([next(req), timeoutPromise]);
+    } finally {
+      if (timer)
+        clearTimeout(timer);
+    }
+  };
+}
+function createRetryInterceptor(maxRetries, delayMs = 50) {
+  return async (req, next) => {
+    let lastError;
+    for (let attempt = 0;attempt <= maxRetries; attempt++) {
+      try {
+        const res = await next(req);
+        if (res.ok || attempt === maxRetries)
+          return res;
+      } catch (err) {
+        lastError = err;
+        if (attempt === maxRetries)
+          throw err;
+      }
+      if (delayMs > 0) {
+        await new Promise((resolve) => setTimeout(resolve, delayMs));
+      }
+    }
+    throw lastError;
+  };
+}
+// src/signal.ts
+var activeConsumer = null;
+var isTrackingEnabled = true;
+function signal(initialValue) {
+  let value = initialValue;
+  const subscribers = new Set;
+  const read = () => {
+    if (isTrackingEnabled && activeConsumer) {
+      subscribers.add(activeConsumer);
+    }
+    return value;
+  };
+  read.set = (newValue) => {
+    if (!Object.is(value, newValue)) {
+      value = newValue;
+      for (const notify of [...subscribers]) {
+        notify();
+      }
+    }
+  };
+  read.update = (updateFn) => {
+    read.set(updateFn(value));
+  };
+  read.asReadonly = () => () => read();
+  return read;
+}
+function computed(computation) {
+  let cachedValue;
+  let isDirty = true;
+  const subscribers = new Set;
+  const recompute = () => {
+    if (!isDirty) {
+      isDirty = true;
+      for (const notify of [...subscribers]) {
+        notify();
+      }
+    }
+  };
+  return () => {
+    if (isTrackingEnabled && activeConsumer) {
+      subscribers.add(activeConsumer);
+    }
+    if (isDirty) {
+      const prevConsumer = activeConsumer;
+      activeConsumer = recompute;
+      try {
+        cachedValue = computation();
+        isDirty = false;
+      } finally {
+        activeConsumer = prevConsumer;
+      }
+    }
+    return cachedValue;
+  };
+}
+function effect(effectFn) {
+  let cleanup;
+  let isDestroyed = false;
+  const run = () => {
+    if (isDestroyed)
+      return;
+    if (typeof cleanup === "function") {
+      cleanup();
+    }
+    const prevConsumer = activeConsumer;
+    activeConsumer = run;
+    try {
+      cleanup = effectFn();
+    } finally {
+      activeConsumer = prevConsumer;
+    }
+  };
+  run();
+  return () => {
+    isDestroyed = true;
+    if (typeof cleanup === "function") {
+      cleanup();
+    }
+  };
+}
+function untracked(fn) {
+  const prevTracking = isTrackingEnabled;
+  isTrackingEnabled = false;
+  try {
+    return fn();
+  } finally {
+    isTrackingEnabled = prevTracking;
+  }
+}
+function linkedSignal(computationOrOptions, shorthandOptions) {
+  let sourceFn;
+  let computationFn;
+  let equalFn;
+  if (typeof computationOrOptions === "function") {
+    sourceFn = computationOrOptions;
+    computationFn = (s) => s;
+    equalFn = shorthandOptions?.equal ?? Object.is;
+  } else {
+    sourceFn = computationOrOptions.source;
+    computationFn = computationOrOptions.computation;
+    equalFn = computationOrOptions.equal ?? Object.is;
+  }
+  let currentValue;
+  let hasValue = false;
+  let previousRecord = undefined;
+  let isDirty = true;
+  const subscribers = new Set;
+  const onSourceChanged = () => {
+    if (!isDirty) {
+      isDirty = true;
+      for (const notify of [...subscribers]) {
+        notify();
+      }
+    }
+  };
+  const recompute = () => {
+    const prevConsumer = activeConsumer;
+    activeConsumer = onSourceChanged;
+    let nextSource;
+    try {
+      nextSource = sourceFn();
+    } finally {
+      activeConsumer = prevConsumer;
+    }
+    if (hasValue && previousRecord && Object.is(nextSource, previousRecord.source)) {
+      isDirty = false;
+      return currentValue;
+    }
+    const nextValue = computationFn(nextSource, previousRecord);
+    currentValue = nextValue;
+    hasValue = true;
+    previousRecord = { source: nextSource, value: currentValue };
+    isDirty = false;
+    return currentValue;
+  };
+  const read = () => {
+    if (isTrackingEnabled && activeConsumer) {
+      subscribers.add(activeConsumer);
+    }
+    if (isDirty || !hasValue) {
+      return recompute();
+    }
+    return currentValue;
+  };
+  read.set = (newValue) => {
+    if (!hasValue || isDirty) {
+      recompute();
+    }
+    if (!equalFn(currentValue, newValue)) {
+      currentValue = newValue;
+      if (previousRecord) {
+        previousRecord.value = newValue;
+      }
+      for (const notify of [...subscribers]) {
+        notify();
+      }
+    }
+  };
+  read.update = (updateFn) => {
+    read.set(updateFn(read()));
+  };
+  read.asReadonly = () => () => read();
+  return read;
+}
+// src/resource.ts
+function resource(options) {
+  const valueSignal = signal(options.initialValue);
+  const statusSignal = signal("idle");
+  const errorSignal = signal(undefined);
+  const isLoadingSignal = signal(false);
+  let activeAbortController = null;
+  const reloadCounter = signal(0);
+  let isDestroyed = false;
+  const load = async (req) => {
+    if (isDestroyed)
+      return;
+    if (activeAbortController) {
+      activeAbortController.abort();
+    }
+    const ac = new AbortController;
+    activeAbortController = ac;
+    const prevStatus = statusSignal();
+    statusSignal.set("loading");
+    isLoadingSignal.set(true);
+    errorSignal.set(undefined);
+    try {
+      const result = await options.loader({
+        request: req,
+        abortSignal: ac.signal,
+        previous: { status: prevStatus }
+      });
+      if (!ac.signal.aborted && !isDestroyed) {
+        valueSignal.set(result);
+        statusSignal.set("resolved");
+        isLoadingSignal.set(false);
+      }
+    } catch (err) {
+      if (!ac.signal.aborted && !isDestroyed) {
+        errorSignal.set(err);
+        statusSignal.set("error");
+        isLoadingSignal.set(false);
+      }
+    } finally {
+      if (activeAbortController === ac) {
+        activeAbortController = null;
+      }
+    }
+  };
+  const disposeEffect = effect(() => {
+    reloadCounter();
+    const req = options.request ? options.request() : undefined;
+    untracked(() => {
+      load(req);
+    });
+  });
+  return {
+    value: valueSignal.asReadonly(),
+    status: statusSignal.asReadonly(),
+    error: errorSignal.asReadonly(),
+    isLoading: isLoadingSignal.asReadonly(),
+    reload() {
+      reloadCounter.update((c) => c + 1);
+    },
+    set(newVal) {
+      if (activeAbortController) {
+        activeAbortController.abort();
+        activeAbortController = null;
+      }
+      valueSignal.set(newVal);
+      statusSignal.set("resolved");
+      errorSignal.set(undefined);
+      isLoadingSignal.set(false);
+    },
+    update(updateFn) {
+      this.set(updateFn(valueSignal()));
+    },
+    destroy() {
+      isDestroyed = true;
+      if (activeAbortController) {
+        activeAbortController.abort();
+        activeAbortController = null;
+      }
+      disposeEffect();
+    }
+  };
+}
+// src/title_strategy.ts
+class TitleStrategy {
+  buildTitle(title, appPrefix) {
+    if (!title)
+      return;
+    return appPrefix ? `${appPrefix} | ${title}` : title;
+  }
+}
+
+class DefaultTitleStrategy extends TitleStrategy {
+  updateTitle(title, ctx) {
+    if (!title)
+      return;
+    if (ctx) {
+      if (!ctx.data)
+        ctx.data = {};
+      ctx.data.title = title;
+    }
+    if (typeof globalThis !== "undefined" && globalThis.document) {
+      globalThis.document.title = title;
+    }
+  }
+}
+var TITLE_STRATEGY = new InjectionToken("supacloud.title-strategy", {
+  scope: "application",
+  factory: () => new DefaultTitleStrategy
 });
-var DB_CLIENT = new InjectionToken("supacloud.db-client", {
-  scope: "application"
+
+// src/route_pipeline.ts
+class RedirectCommand {
+  redirectTo;
+  navigationExtras;
+  constructor(redirectTo, navigationExtras) {
+    this.redirectTo = redirectTo;
+    this.navigationExtras = navigationExtras;
+  }
+}
+function isRedirectCommand(val) {
+  return val instanceof RedirectCommand || typeof val === "object" && val !== null && "redirectTo" in val && val.constructor?.name === "RedirectCommand";
+}
+async function executeRoutePipeline(route, ctx, componentInstance, options) {
+  const emit = (type, data) => {
+    if (options?.onEvent) {
+      options.onEvent({
+        type,
+        url: ctx.url,
+        timestamp: Date.now(),
+        data
+      });
+    }
+  };
+  emit("NavigationStart");
+  emit("RoutesRecognized", { method: route.method, path: route.path });
+  if (route.canMatch && route.canMatch.length > 0) {
+    emit("GuardsCheckStart", { stage: "canMatch" });
+    for (const guard of route.canMatch) {
+      if (typeof guard === "function") {
+        const can = await guard(ctx);
+        if (isRedirectCommand(can)) {
+          emit("GuardsCheckEnd", { stage: "canMatch", allowed: false });
+          emit("NavigationCancel", { reason: "Redirected by CanMatch guard" });
+          return {
+            matched: true,
+            status: can.navigationExtras?.status ?? 302,
+            redirect: String(can.redirectTo),
+            headers: { Location: String(can.redirectTo), ...can.navigationExtras?.headers ?? {} }
+          };
+        }
+        if (!can) {
+          emit("GuardsCheckEnd", { stage: "canMatch", allowed: false });
+          emit("NavigationCancel", { reason: "CanMatch guard rejected" });
+          return { matched: false, status: 404, error: "Route match rejected by CanMatch guard" };
+        }
+      }
+    }
+    emit("GuardsCheckEnd", { stage: "canMatch", allowed: true });
+  }
+  if (route.guards && route.guards.length > 0) {
+    emit("GuardsCheckStart", { stage: "canActivate" });
+    for (const guard of route.guards) {
+      if (typeof guard === "function") {
+        const allowed = await guard(ctx);
+        if (isRedirectCommand(allowed)) {
+          emit("GuardsCheckEnd", { stage: "canActivate", allowed: false });
+          emit("NavigationCancel", { reason: "Redirected by CanActivate guard" });
+          return {
+            matched: true,
+            status: allowed.navigationExtras?.status ?? 302,
+            redirect: String(allowed.redirectTo),
+            headers: { Location: String(allowed.redirectTo), ...allowed.navigationExtras?.headers ?? {} }
+          };
+        }
+        if (!allowed) {
+          emit("GuardsCheckEnd", { stage: "canActivate", allowed: false });
+          emit("NavigationCancel", { reason: "CanActivate guard rejected" });
+          return { matched: true, status: 403, error: "Route activation rejected by CanActivate guard" };
+        }
+      }
+    }
+    emit("GuardsCheckEnd", { stage: "canActivate", allowed: true });
+  }
+  let resolvedData;
+  if (route.resolvers && Object.keys(route.resolvers).length > 0) {
+    emit("ResolveStart", { keys: Object.keys(route.resolvers) });
+    resolvedData = await executeResolvers(route.resolvers, ctx);
+    ctx.resolved = { ...ctx.resolved ?? {}, ...resolvedData };
+    ctx.data = { ...ctx.data ?? {}, ...route.data ?? {}, ...resolvedData };
+    emit("ResolveEnd", { keys: Object.keys(route.resolvers) });
+  } else if (route.data) {
+    ctx.data = { ...ctx.data ?? {}, ...route.data };
+  }
+  let responseBody;
+  try {
+    emit("ExecutionStart");
+    if (route.invoker && typeof route.invoker === "function") {
+      responseBody = await route.invoker(componentInstance, ctx);
+    } else if (componentInstance && typeof route.handler === "string" && typeof componentInstance[route.handler] === "function") {
+      responseBody = await componentInstance[route.handler](ctx);
+    } else if (typeof route.handler === "function") {
+      responseBody = await route.handler(ctx);
+    } else {
+      throw new Error(`Handler '${String(route.handler)}' is not executable on component instance.`);
+    }
+    if (isRedirectCommand(responseBody)) {
+      emit("ExecutionEnd");
+      return {
+        matched: true,
+        status: responseBody.navigationExtras?.status ?? 302,
+        redirect: String(responseBody.redirectTo),
+        headers: { Location: String(responseBody.redirectTo), ...responseBody.navigationExtras?.headers ?? {} },
+        resolvedData
+      };
+    }
+    emit("ExecutionEnd");
+  } catch (err) {
+    const errorMsg = err instanceof Error ? err.message : String(err);
+    emit("NavigationError", { error: errorMsg });
+    return {
+      matched: true,
+      status: 500,
+      error: errorMsg,
+      resolvedData
+    };
+  }
+  if (route.canDeactivate && route.canDeactivate.length > 0 && componentInstance) {
+    emit("GuardsCheckStart", { stage: "canDeactivate" });
+    for (const guard of route.canDeactivate) {
+      if (typeof guard === "function") {
+        const canLeave = await guard(componentInstance, ctx);
+        if (!canLeave) {
+          emit("GuardsCheckEnd", { stage: "canDeactivate", allowed: false });
+          emit("NavigationCancel", { reason: "CanDeactivate guard rejected" });
+          return {
+            matched: true,
+            status: 409,
+            body: responseBody,
+            error: "Route deactivation rejected by CanDeactivate guard",
+            resolvedData
+          };
+        }
+      }
+    }
+    emit("GuardsCheckEnd", { stage: "canDeactivate", allowed: true });
+  }
+  if (route.title) {
+    const titleStrategy = options?.titleStrategy ?? new DefaultTitleStrategy;
+    titleStrategy.updateTitle(route.title, ctx);
+  }
+  emit("NavigationEnd");
+  return {
+    matched: true,
+    status: 200,
+    body: responseBody,
+    resolvedData
+  };
+}
+// src/testing.ts
+class TestBed {
+  static declaredProviders = [];
+  static overriddenProviders = new Map;
+  static activeInjector = null;
+  static instances = new Map;
+  static configureTestingModule(moduleDef) {
+    TestBed.resetTestingModule();
+    const allProviders = [...moduleDef.providers ?? []];
+    if (moduleDef.imports) {
+      for (const imp of moduleDef.imports) {
+        if (imp && typeof imp === "object" && "providers" in imp && Array.isArray(imp.providers)) {
+          allProviders.push(...imp.providers);
+        }
+      }
+    }
+    TestBed.declaredProviders = flattenProviders(allProviders);
+    return TestBed;
+  }
+  static overrideProvider(token, provider) {
+    TestBed.overriddenProviders.set(resolveForwardRef(token), provider);
+    TestBed.activeInjector = null;
+    return TestBed;
+  }
+  static inject(token, notFoundValue, flags) {
+    const injector = TestBed.getOrCreateInjector();
+    return runInInjectionContext(injector, () => {
+      const resolved = resolveForwardRef(token);
+      const val = injector.get(resolved, flags);
+      if (val === undefined) {
+        if (notFoundValue !== undefined)
+          return notFoundValue;
+        if (flags?.optional)
+          return;
+        throw new Error(`TestBed: No provider found for token ${String(resolved)}`);
+      }
+      return val;
+    });
+  }
+  static injectAll(token) {
+    const injector = TestBed.getOrCreateInjector();
+    return runInInjectionContext(injector, () => {
+      return injectAll(token);
+    });
+  }
+  static run(fn) {
+    const injector = TestBed.getOrCreateInjector();
+    return runInInjectionContext(injector, fn);
+  }
+  static resetTestingModule() {
+    TestBed.declaredProviders = [];
+    TestBed.overriddenProviders.clear();
+    TestBed.activeInjector = null;
+    TestBed.instances.clear();
+    return TestBed;
+  }
+  static getOrCreateInjector() {
+    if (TestBed.activeInjector)
+      return TestBed.activeInjector;
+    const effectiveProviders = new Map;
+    const multiProviders = new Map;
+    for (const p of TestBed.declaredProviders) {
+      const token = typeof p === "function" ? resolveForwardRef(p) : resolveForwardRef(p.provide);
+      if (typeof p !== "function" && p.multi) {
+        const list = multiProviders.get(token) ?? [];
+        list.push(p);
+        multiProviders.set(token, list);
+      } else {
+        effectiveProviders.set(token, p);
+      }
+    }
+    for (const [token, p] of TestBed.overriddenProviders) {
+      if (typeof p !== "function" && p.multi) {
+        const list = multiProviders.get(token) ?? [];
+        list.push(p);
+        multiProviders.set(token, list);
+      } else {
+        effectiveProviders.set(token, p);
+        multiProviders.delete(token);
+      }
+    }
+    const instances = TestBed.instances;
+    const rootInjector = {
+      get(token, flags) {
+        const resolved = resolveForwardRef(token);
+        if (instances.has(resolved)) {
+          return instances.get(resolved);
+        }
+        if (resolved instanceof InjectionToken && instances.has(resolved.name)) {
+          return instances.get(resolved.name);
+        }
+        if (multiProviders.has(resolved)) {
+          const providers = multiProviders.get(resolved);
+          const results = providers.map((prov) => {
+            if (isValueProvider(prov))
+              return prov.useValue;
+            if (isFactoryProvider(prov))
+              return runInInjectionContext(rootInjector, () => prov.useFactory());
+            if (isClassProvider(prov))
+              return runInInjectionContext(rootInjector, () => new prov.useClass);
+            if (isExistingProvider(prov))
+              return rootInjector.get(prov.useExisting);
+            return;
+          });
+          instances.set(resolved, results);
+          if (resolved instanceof InjectionToken) {
+            instances.set(resolved.name, results);
+          }
+          return results;
+        }
+        const provider = effectiveProviders.get(resolved);
+        if (!provider) {
+          if (flags?.optional)
+            return;
+          if (resolved instanceof InjectionToken && resolved.factory) {
+            const inst = resolved.factory();
+            instances.set(resolved, inst);
+            return inst;
+          }
+          if (typeof resolved === "function") {
+            try {
+              const inst = new resolved;
+              instances.set(resolved, inst);
+              return inst;
+            } catch {
+              return;
+            }
+          }
+          return;
+        }
+        let created;
+        if (typeof provider === "function") {
+          created = runInInjectionContext(rootInjector, () => new provider);
+        } else if (isValueProvider(provider)) {
+          created = provider.useValue;
+        } else if (isFactoryProvider(provider)) {
+          created = runInInjectionContext(rootInjector, () => provider.useFactory());
+        } else if (isClassProvider(provider)) {
+          created = runInInjectionContext(rootInjector, () => new provider.useClass);
+        } else if (isExistingProvider(provider)) {
+          created = rootInjector.get(provider.useExisting);
+        }
+        instances.set(resolved, created);
+        return created;
+      }
+    };
+    TestBed.activeInjector = rootInjector;
+    instances.set(INJECTOR, rootInjector);
+    return rootInjector;
+  }
+}
+// src/route_provider.ts
+var ROUTE_CONFIG = new InjectionToken("supacloud:route-config");
+var APP_BASE_HREF = new InjectionToken("supacloud.app-base-href", {
+  scope: "application",
+  factory: () => "/"
 });
+var ROUTER_CONFIGURATION = new InjectionToken("supacloud.router-configuration", {
+  scope: "application",
+  factory: () => ({ onSameUrlNavigation: "ignore", paramsInheritanceStrategy: "emptyOnly" })
+});
+function withComponentInputBinding() {
+  return {
+    kind: "componentInputBinding",
+    providers: [
+      {
+        provide: new InjectionToken("supacloud.with-component-input-binding"),
+        useValue: true
+      }
+    ]
+  };
+}
+function withRouterConfig(options) {
+  return {
+    kind: "routerConfig",
+    providers: [
+      {
+        provide: ROUTER_CONFIGURATION,
+        useValue: options
+      }
+    ]
+  };
+}
+function withTitleStrategy(strategy) {
+  return {
+    kind: "titleStrategy",
+    providers: [
+      typeof strategy === "function" ? { provide: TITLE_STRATEGY, useClass: strategy } : { provide: TITLE_STRATEGY, useValue: strategy }
+    ]
+  };
+}
+function provideRouter(routes, ...features) {
+  const featureProviders = [];
+  for (const feature of features) {
+    if (feature && Array.isArray(feature.providers)) {
+      featureProviders.push(...feature.providers);
+    }
+  }
+  return makeEnvironmentProviders([
+    {
+      provide: ROUTE_CONFIG,
+      useValue: routes
+    },
+    ...featureProviders
+  ]);
+}
+// src/location.ts
+function normalizePath(path) {
+  if (!path)
+    return "/";
+  const clean = path.replace(/\/+/g, "/");
+  return clean.startsWith("/") ? clean : `/${clean}`;
+}
+function stripTrailingSlash(path) {
+  if (!path || path === "/")
+    return "/";
+  return path.replace(/\/+$/, "");
+}
+function joinWithSlash(start, end) {
+  if (!start)
+    return end.startsWith("/") ? end : `/${end}`;
+  if (!end)
+    return start;
+  const s = stripTrailingSlash(start);
+  const e = end.startsWith("/") ? end.slice(1) : end;
+  return `${s}/${e}`;
+}
+// src/transfer_state.ts
+function makeStateKey(key) {
+  return key;
+}
+
+class TransferState {
+  store = new Map;
+  get(key, defaultValue) {
+    if (this.store.has(key)) {
+      return this.store.get(key);
+    }
+    return defaultValue;
+  }
+  set(key, value) {
+    this.store.set(key, value);
+  }
+  hasKey(key) {
+    return this.store.has(key);
+  }
+  remove(key) {
+    this.store.delete(key);
+  }
+  isEmpty() {
+    return this.store.size === 0;
+  }
+  toJson() {
+    const obj = {};
+    for (const [k, v] of this.store.entries()) {
+      obj[k] = v;
+    }
+    return JSON.stringify(obj);
+  }
+  static fromJson(json) {
+    const state = new TransferState;
+    try {
+      const parsed = JSON.parse(json);
+      if (parsed && typeof parsed === "object" && parsed !== null) {
+        for (const [k, v] of Object.entries(parsed)) {
+          state.set(k, v);
+        }
+      }
+    } catch {}
+    return state;
+  }
+  static fromObject(record) {
+    const state = new TransferState;
+    for (const [k, v] of Object.entries(record)) {
+      state.set(k, v);
+    }
+    return state;
+  }
+}
+var TRANSFER_STATE = new InjectionToken("supacloud.transfer-state", {
+  scope: "application",
+  factory: () => new TransferState
+});
+// src/platform.ts
+var PLATFORM_SERVER_ID = "server";
+var PLATFORM_BROWSER_ID = "browser";
+var PLATFORM_EDGE_ID = "edge";
+function detectPlatform() {
+  if (typeof window !== "undefined" && typeof window.document !== "undefined") {
+    return PLATFORM_BROWSER_ID;
+  }
+  if (typeof globalThis.EdgeRuntime === "string") {
+    return PLATFORM_EDGE_ID;
+  }
+  return PLATFORM_SERVER_ID;
+}
+var DOCUMENT = new InjectionToken("supacloud.document", {
+  scope: "application",
+  factory: () => {
+    if (typeof globalThis !== "undefined" && globalThis.document) {
+      return globalThis.document;
+    }
+    return;
+  }
+});
+var PLATFORM_ID = new InjectionToken("supacloud.platform-id", {
+  scope: "application",
+  factory: () => detectPlatform()
+});
+function isPlatformBrowser(platformId) {
+  return platformId === PLATFORM_BROWSER_ID;
+}
+function isPlatformServer(platformId) {
+  return platformId === PLATFORM_SERVER_ID || platformId === PLATFORM_EDGE_ID;
+}
+function isPlatformEdge(platformId) {
+  return platformId === PLATFORM_EDGE_ID;
+}
+// src/http_params.ts
+class HttpParams {
+  map;
+  constructor(options) {
+    this.map = new Map;
+    if (!options)
+      return;
+    if (options.fromString) {
+      const raw = options.fromString.startsWith("?") ? options.fromString.slice(1) : options.fromString;
+      if (raw.length > 0) {
+        const pairs = raw.split("&");
+        for (const pair of pairs) {
+          if (!pair)
+            continue;
+          const eqIndex = pair.indexOf("=");
+          const rawKey = eqIndex >= 0 ? pair.slice(0, eqIndex) : pair;
+          const rawVal = eqIndex >= 0 ? pair.slice(eqIndex + 1) : "";
+          const key = decodeURIComponent(rawKey.replace(/\+/g, " "));
+          const val = decodeURIComponent(rawVal.replace(/\+/g, " "));
+          const existing = this.map.get(key) ?? [];
+          existing.push(val);
+          this.map.set(key, existing);
+        }
+      }
+    }
+    if (options.fromObject) {
+      for (const [key, val] of Object.entries(options.fromObject)) {
+        if (val === undefined || val === null)
+          continue;
+        if (Array.isArray(val)) {
+          this.map.set(key, val.map((v) => String(v)));
+        } else {
+          this.map.set(key, [String(val)]);
+        }
+      }
+    }
+  }
+  clone(newMap) {
+    const clone = new HttpParams;
+    for (const [k, v] of newMap.entries()) {
+      clone.map.set(k, [...v]);
+    }
+    return clone;
+  }
+  has(param) {
+    return this.map.has(param);
+  }
+  get(param) {
+    const values = this.map.get(param);
+    return values && values.length > 0 ? values[0] : null;
+  }
+  getAll(param) {
+    const values = this.map.get(param);
+    return values ? [...values] : null;
+  }
+  keys() {
+    return Array.from(this.map.keys());
+  }
+  set(param, value) {
+    const newMap = new Map(this.map);
+    newMap.set(param, [String(value)]);
+    return this.clone(newMap);
+  }
+  append(param, value) {
+    const newMap = new Map(this.map);
+    const existing = newMap.get(param) ? [...newMap.get(param)] : [];
+    existing.push(String(value));
+    newMap.set(param, existing);
+    return this.clone(newMap);
+  }
+  delete(param, value) {
+    if (!this.map.has(param))
+      return this;
+    const newMap = new Map(this.map);
+    if (value === undefined) {
+      newMap.delete(param);
+    } else {
+      const target = String(value);
+      const existing = newMap.get(param).filter((v) => v !== target);
+      if (existing.length === 0) {
+        newMap.delete(param);
+      } else {
+        newMap.set(param, existing);
+      }
+    }
+    return this.clone(newMap);
+  }
+  toString() {
+    const parts = [];
+    for (const [key, values] of this.map.entries()) {
+      const encodedKey = encodeURIComponent(key);
+      for (const val of values) {
+        parts.push(`${encodedKey}=${encodeURIComponent(val)}`);
+      }
+    }
+    return parts.join("&");
+  }
+}
+// src/http_headers.ts
+class HttpHeaders {
+  headersMap;
+  originalNames;
+  constructor(headers) {
+    this.headersMap = new Map;
+    this.originalNames = new Map;
+    if (!headers)
+      return;
+    if (headers instanceof HttpHeaders) {
+      for (const [k, v] of headers.headersMap.entries()) {
+        this.headersMap.set(k, [...v]);
+        this.originalNames.set(k, headers.originalNames.get(k) ?? k);
+      }
+      return;
+    }
+    for (const [key, value] of Object.entries(headers)) {
+      if (value === undefined || value === null)
+        continue;
+      const lower = key.toLowerCase();
+      this.originalNames.set(lower, key);
+      if (Array.isArray(value)) {
+        this.headersMap.set(lower, [...value]);
+      } else {
+        this.headersMap.set(lower, [String(value)]);
+      }
+    }
+  }
+  clone(newMap, newNames) {
+    const clone = new HttpHeaders;
+    for (const [k, v] of newMap.entries()) {
+      clone.headersMap.set(k, [...v]);
+    }
+    for (const [k, v] of newNames.entries()) {
+      clone.originalNames.set(k, v);
+    }
+    return clone;
+  }
+  has(name) {
+    return this.headersMap.has(name.toLowerCase());
+  }
+  get(name) {
+    const values = this.headersMap.get(name.toLowerCase());
+    return values && values.length > 0 ? values[0] : null;
+  }
+  getAll(name) {
+    const values = this.headersMap.get(name.toLowerCase());
+    return values ? [...values] : null;
+  }
+  keys() {
+    return Array.from(this.originalNames.values());
+  }
+  set(name, value) {
+    const lower = name.toLowerCase();
+    const newMap = new Map(this.headersMap);
+    const newNames = new Map(this.originalNames);
+    const valArray = Array.isArray(value) ? [...value] : [String(value)];
+    newMap.set(lower, valArray);
+    newNames.set(lower, name);
+    return this.clone(newMap, newNames);
+  }
+  append(name, value) {
+    const lower = name.toLowerCase();
+    const newMap = new Map(this.headersMap);
+    const newNames = new Map(this.originalNames);
+    const existing = newMap.get(lower) ? [...newMap.get(lower)] : [];
+    if (Array.isArray(value)) {
+      existing.push(...value);
+    } else {
+      existing.push(String(value));
+    }
+    newMap.set(lower, existing);
+    if (!newNames.has(lower)) {
+      newNames.set(lower, name);
+    }
+    return this.clone(newMap, newNames);
+  }
+  delete(name) {
+    const lower = name.toLowerCase();
+    if (!this.headersMap.has(lower))
+      return this;
+    const newMap = new Map(this.headersMap);
+    const newNames = new Map(this.originalNames);
+    newMap.delete(lower);
+    newNames.delete(lower);
+    return this.clone(newMap, newNames);
+  }
+  toObject() {
+    const result = {};
+    for (const [lower, values] of this.headersMap.entries()) {
+      const originalName = this.originalNames.get(lower) ?? lower;
+      result[originalName] = values.join(", ");
+    }
+    return result;
+  }
+}
+// src/http_context.ts
+class HttpContextToken {
+  defaultValue;
+  constructor(defaultValue) {
+    this.defaultValue = defaultValue;
+  }
+}
+
+class HttpContext {
+  map = new Map;
+  set(token, value) {
+    this.map.set(token, value);
+    return this;
+  }
+  get(token) {
+    if (this.map.has(token)) {
+      return this.map.get(token);
+    }
+    return token.defaultValue();
+  }
+  delete(token) {
+    this.map.delete(token);
+    return this;
+  }
+  has(token) {
+    return this.map.has(token);
+  }
+  keys() {
+    return this.map.keys();
+  }
+}
+// src/http_client.ts
+var HTTP_CLIENT_CONFIG = new InjectionToken("HTTP_CLIENT_CONFIG", { scope: "application", factory: () => ({}) });
+var HTTP_INTERCEPTORS = new InjectionToken("HTTP_INTERCEPTORS", { scope: "application", factory: () => [] });
+
+class HttpErrorResponse extends Error {
+  status;
+  statusText;
+  url;
+  error;
+  constructor(init) {
+    super(`Http failure response for ${init.url ?? "unknown"}: ${init.status ?? 0} ${init.statusText ?? "Unknown Error"}`);
+    this.name = "HttpErrorResponse";
+    this.status = init.status ?? 0;
+    this.statusText = init.statusText ?? "Unknown Error";
+    this.url = init.url ?? null;
+    this.error = init.error ?? null;
+  }
+}
+function withFetch(customFetch) {
+  return {
+    kind: "Fetch",
+    providers: [
+      {
+        provide: HTTP_CLIENT_CONFIG,
+        useFactory: () => ({ fetch: customFetch ?? (typeof globalThis.fetch === "function" ? globalThis.fetch.bind(globalThis) : undefined) })
+      }
+    ]
+  };
+}
+function withRequestsMadeViaParent() {
+  return {
+    kind: "ParentRequests",
+    providers: []
+  };
+}
+function provideHttpClient(...features) {
+  const providers = [
+    HttpClient
+  ];
+  for (const feature of features) {
+    providers.push(...feature.providers);
+  }
+  return makeEnvironmentProviders(providers);
+}
+
+class HttpClient {
+  config;
+  interceptors;
+  constructor(config, interceptors) {
+    if (config) {
+      this.config = config;
+    } else {
+      try {
+        this.config = inject(HTTP_CLIENT_CONFIG, { optional: true }) ?? {};
+      } catch {
+        this.config = {};
+      }
+    }
+    if (interceptors) {
+      this.interceptors = [...interceptors];
+    } else {
+      try {
+        const resolved = injectAll(HTTP_INTERCEPTORS);
+        this.interceptors = resolved.flat();
+      } catch {
+        this.interceptors = [];
+      }
+    }
+  }
+  get(url, options) {
+    return this.request("GET", url, options);
+  }
+  post(url, body, options) {
+    return this.request("POST", url, { ...options, body });
+  }
+  put(url, body, options) {
+    return this.request("PUT", url, { ...options, body });
+  }
+  delete(url, options) {
+    return this.request("DELETE", url, options);
+  }
+  patch(url, body, options) {
+    return this.request("PATCH", url, { ...options, body });
+  }
+  async request(method, url, options) {
+    let targetUrl = url;
+    if (this.config.baseUrl && !/^https?:\/\//i.test(targetUrl)) {
+      const base = this.config.baseUrl.endsWith("/") ? this.config.baseUrl.slice(0, -1) : this.config.baseUrl;
+      const rel = targetUrl.startsWith("/") ? targetUrl : `/${targetUrl}`;
+      targetUrl = `${base}${rel}`;
+    }
+    if (options?.params) {
+      const params = options.params instanceof HttpParams ? options.params : new HttpParams({ fromObject: options.params });
+      const qs = params.toString();
+      if (qs.length > 0) {
+        targetUrl += targetUrl.includes("?") ? `&${qs}` : `?${qs}`;
+      }
+    }
+    let headers = {};
+    if (options?.headers) {
+      if (options.headers instanceof HttpHeaders) {
+        headers = options.headers.toObject();
+      } else {
+        for (const [k, v] of Object.entries(options.headers)) {
+          if (v !== undefined && v !== null) {
+            headers[k] = Array.isArray(v) ? v.join(", ") : String(v);
+          }
+        }
+      }
+    }
+    let body = options?.body;
+    if (body !== undefined && body !== null && typeof body === "object" && !(body instanceof FormData) && !(body instanceof Blob) && !(body instanceof URLSearchParams) && !(body instanceof ArrayBuffer)) {
+      body = JSON.stringify(body);
+      const hasContentType = Object.keys(headers).some((k) => k.toLowerCase() === "content-type");
+      if (!hasContentType) {
+        headers["content-type"] = "application/json";
+      }
+    }
+    const payload = {
+      method: method.toUpperCase(),
+      url: targetUrl,
+      headers,
+      body,
+      context: options?.context
+    };
+    const fetchFn = this.config.fetch ?? (typeof globalThis.fetch === "function" ? globalThis.fetch.bind(globalThis) : undefined);
+    if (!fetchFn) {
+      throw new Error("No fetch implementation available. Provide withFetch() in provideHttpClient or run in an environment with global fetch.");
+    }
+    const finalHandler = async (req) => {
+      return fetchFn(req.url, {
+        method: req.method,
+        headers: req.headers,
+        body: req.body ?? undefined,
+        signal: options?.signal
+      });
+    };
+    const pipeline = this.interceptors.reduceRight((next, interceptor) => (req) => interceptor(req, next), finalHandler);
+    const response = await pipeline(payload);
+    if (options?.observe === "response") {
+      return response;
+    }
+    if (!response.ok) {
+      let errorBody;
+      try {
+        errorBody = await response.json();
+      } catch {
+        try {
+          errorBody = await response.text();
+        } catch {
+          errorBody = null;
+        }
+      }
+      throw new HttpErrorResponse({
+        url: response.url || targetUrl,
+        status: response.status,
+        statusText: response.statusText,
+        error: errorBody
+      });
+    }
+    if (options?.responseType === "text") {
+      return await response.text();
+    }
+    if (options?.responseType === "blob") {
+      return await response.blob();
+    }
+    const contentType = response.headers?.get("content-type") ?? "";
+    if (contentType.includes("application/json")) {
+      return await response.json();
+    }
+    const text = await response.text();
+    try {
+      return JSON.parse(text);
+    } catch {
+      return text;
+    }
+  }
+}
+HttpClient = __legacyDecorateClassTS([
+  Injectable({ providedIn: "root" })
+], HttpClient);
+// src/url_tree.ts
+class UrlSegmentGroup {
+  segments;
+  children;
+  parent = null;
+  constructor(segments, children = {}) {
+    this.segments = segments;
+    this.children = children;
+    for (const child of Object.values(children)) {
+      child.parent = this;
+    }
+  }
+  hasChildren() {
+    return Object.keys(this.children).length > 0;
+  }
+}
+
+class UrlTree {
+  root;
+  queryParams;
+  fragment;
+  constructor(root, queryParams = {}, fragment = null) {
+    this.root = root;
+    this.queryParams = queryParams;
+    this.fragment = fragment;
+  }
+  get queryParamMap() {
+    return new Map(Object.entries(this.queryParams));
+  }
+  toString() {
+    return new DefaultUrlSerializer().serialize(this);
+  }
+}
+
+class UrlSerializer {
+}
+
+class DefaultUrlSerializer {
+  parse(url) {
+    let remaining = url.trim();
+    let fragment = null;
+    const fragIndex = remaining.indexOf("#");
+    if (fragIndex >= 0) {
+      fragment = decodeURIComponent(remaining.slice(fragIndex + 1));
+      remaining = remaining.slice(0, fragIndex);
+    }
+    const queryParams = {};
+    const queryIndex = remaining.indexOf("?");
+    if (queryIndex >= 0) {
+      const rawQuery = remaining.slice(queryIndex + 1);
+      remaining = remaining.slice(0, queryIndex);
+      if (rawQuery.length > 0) {
+        for (const pair of rawQuery.split("&")) {
+          if (!pair)
+            continue;
+          const eq = pair.indexOf("=");
+          const rawKey = eq >= 0 ? pair.slice(0, eq) : pair;
+          const rawVal = eq >= 0 ? pair.slice(eq + 1) : "";
+          queryParams[decodeURIComponent(rawKey.replace(/\+/g, " "))] = decodeURIComponent(rawVal.replace(/\+/g, " "));
+        }
+      }
+    }
+    const rawSegments = remaining.split("/").filter((s) => s.length > 0);
+    const segments = [];
+    for (const rawSeg of rawSegments) {
+      const matrixParts = rawSeg.split(";");
+      const path = decodeURIComponent(matrixParts[0]);
+      const parameters = {};
+      for (let i = 1;i < matrixParts.length; i++) {
+        const part = matrixParts[i];
+        if (!part)
+          continue;
+        const eq = part.indexOf("=");
+        const pKey = eq >= 0 ? part.slice(0, eq) : part;
+        const pVal = eq >= 0 ? part.slice(eq + 1) : "";
+        parameters[decodeURIComponent(pKey)] = decodeURIComponent(pVal);
+      }
+      segments.push({ path, parameters });
+    }
+    const root = new UrlSegmentGroup(segments);
+    return new UrlTree(root, queryParams, fragment);
+  }
+  serialize(tree) {
+    const segmentStrings = [];
+    for (const seg of tree.root.segments) {
+      let segStr = encodeURIComponent(seg.path);
+      const paramKeys = Object.keys(seg.parameters).sort();
+      for (const pk of paramKeys) {
+        segStr += `;${encodeURIComponent(pk)}=${encodeURIComponent(seg.parameters[pk])}`;
+      }
+      segmentStrings.push(segStr);
+    }
+    let path = "/" + segmentStrings.join("/");
+    if (segmentStrings.length === 0) {
+      path = "/";
+    }
+    const qKeys = Object.keys(tree.queryParams).sort();
+    if (qKeys.length > 0) {
+      const qParts = qKeys.map((k) => `${encodeURIComponent(k)}=${encodeURIComponent(tree.queryParams[k])}`);
+      path += `?${qParts.join("&")}`;
+    }
+    if (tree.fragment !== null && tree.fragment !== undefined) {
+      path += `#${encodeURIComponent(tree.fragment)}`;
+    }
+    return path;
+  }
+}
+// src/forms.ts
+class AbstractControl {
+  _value;
+  _status = "VALID";
+  _errors = null;
+  _pristine = true;
+  _touched = false;
+  _parent = null;
+  _validator = null;
+  _asyncValidator = null;
+  constructor(validatorOrOpts, asyncValidator) {
+    if (validatorOrOpts && typeof validatorOrOpts === "object" && !Array.isArray(validatorOrOpts) && (("validators" in validatorOrOpts) || ("asyncValidators" in validatorOrOpts))) {
+      const opts = validatorOrOpts;
+      this._validator = Validators.compose(opts.validators ? Array.isArray(opts.validators) ? opts.validators : [opts.validators] : null);
+      this._asyncValidator = Validators.composeAsync(opts.asyncValidators ? Array.isArray(opts.asyncValidators) ? opts.asyncValidators : [opts.asyncValidators] : null);
+    } else {
+      const v = validatorOrOpts;
+      this._validator = Validators.compose(v ? Array.isArray(v) ? v : [v] : null);
+      this._asyncValidator = Validators.composeAsync(asyncValidator ? Array.isArray(asyncValidator) ? asyncValidator : [asyncValidator] : null);
+    }
+  }
+  get value() {
+    return this._value;
+  }
+  setRawValue(val) {
+    this._value = val;
+  }
+  get status() {
+    return this._status;
+  }
+  get valid() {
+    return this._status === "VALID";
+  }
+  get invalid() {
+    return this._status === "INVALID";
+  }
+  get pending() {
+    return this._status === "PENDING";
+  }
+  get disabled() {
+    return this._status === "DISABLED";
+  }
+  get enabled() {
+    return this._status !== "DISABLED";
+  }
+  get errors() {
+    return this._errors;
+  }
+  get pristine() {
+    return this._pristine;
+  }
+  get dirty() {
+    return !this._pristine;
+  }
+  get touched() {
+    return this._touched;
+  }
+  get untouched() {
+    return !this._touched;
+  }
+  get parent() {
+    return this._parent;
+  }
+  setParent(parent) {
+    this._parent = parent;
+  }
+  markAsTouched() {
+    this._touched = true;
+  }
+  markAsUntouched() {
+    this._touched = false;
+  }
+  markAsDirty() {
+    this._pristine = false;
+    if (this._parent)
+      this._parent.markAsDirty();
+  }
+  markAsPristine() {
+    this._pristine = true;
+  }
+  disable() {
+    this._status = "DISABLED";
+    this._errors = null;
+    if (this._parent)
+      this._parent.updateValueAndValidity();
+  }
+  enable() {
+    this._status = "VALID";
+    this.updateValueAndValidity();
+  }
+  setErrors(errors) {
+    this._errors = errors;
+    this._status = errors ? "INVALID" : "VALID";
+  }
+  hasError(errorCode, path) {
+    return this.getError(errorCode, path) !== null;
+  }
+  getError(errorCode, path) {
+    const control = path ? this.get(path) : this;
+    if (!control || !control._errors)
+      return null;
+    return control._errors[errorCode] ?? null;
+  }
+  get(_path) {
+    return null;
+  }
+  updateValueAndValidity() {
+    if (this.disabled) {
+      this._status = "DISABLED";
+      this._errors = null;
+      return;
+    }
+    if (this._validator) {
+      this._errors = this._validator(this);
+    } else {
+      this._errors = null;
+    }
+    this._status = this._errors ? "INVALID" : "VALID";
+    if (this._status === "VALID" && this._asyncValidator) {
+      this._status = "PENDING";
+      this._asyncValidator(this).then((errors) => {
+        if (this._status === "PENDING") {
+          this.setErrors(errors);
+        }
+      });
+    }
+    if (this._parent) {
+      this._parent.updateValueAndValidity();
+    }
+  }
+}
+
+class FormControl extends AbstractControl {
+  constructor(formState, validatorOrOpts, asyncValidator) {
+    super(validatorOrOpts, asyncValidator);
+    if (formState && typeof formState === "object" && "value" in formState && "disabled" in formState) {
+      this.setRawValue(formState.value);
+      if (formState.disabled) {
+        this.disable();
+      } else {
+        this.updateValueAndValidity();
+      }
+    } else {
+      this.setRawValue(formState);
+      this.updateValueAndValidity();
+    }
+  }
+  setValue(value) {
+    this.setRawValue(value);
+    this.markAsDirty();
+    this.updateValueAndValidity();
+  }
+  patchValue(value) {
+    this.setValue(value);
+  }
+  reset(formState) {
+    this.setRawValue(formState !== undefined ? formState : null);
+    this.markAsPristine();
+    this.markAsUntouched();
+    this.updateValueAndValidity();
+  }
+}
+
+class FormGroup extends AbstractControl {
+  controls;
+  constructor(controls, validatorOrOpts, asyncValidator) {
+    super(validatorOrOpts, asyncValidator);
+    this.controls = controls;
+    for (const ctrl of Object.values(controls)) {
+      ctrl.setParent(this);
+    }
+    this.updateValueAndValidity();
+  }
+  get value() {
+    const res = {};
+    for (const [key, ctrl] of Object.entries(this.controls)) {
+      res[key] = ctrl.value;
+    }
+    return res;
+  }
+  get(path) {
+    const parts = Array.isArray(path) ? path : path.split(".");
+    let current = this;
+    for (const part of parts) {
+      if (!current)
+        return null;
+      if (current instanceof FormGroup) {
+        current = current.controls[String(part)] ?? null;
+      } else if (current instanceof FormArray) {
+        current = current.at(Number(part)) ?? null;
+      } else {
+        return null;
+      }
+    }
+    return current;
+  }
+  addControl(name, control) {
+    this.controls[name] = control;
+    control.setParent(this);
+    this.updateValueAndValidity();
+  }
+  removeControl(name) {
+    const ctrl = this.controls[name];
+    if (ctrl) {
+      ctrl.setParent(null);
+      delete this.controls[name];
+      this.updateValueAndValidity();
+    }
+  }
+  setControl(name, control) {
+    this.removeControl(name);
+    this.addControl(name, control);
+  }
+  contains(name) {
+    return Boolean(this.controls[name]);
+  }
+  setValue(value) {
+    for (const [key, val] of Object.entries(value)) {
+      if (this.controls[key]) {
+        this.controls[key].setValue(val);
+      }
+    }
+    this.markAsDirty();
+  }
+  patchValue(value) {
+    for (const [key, val] of Object.entries(value)) {
+      if (this.controls[key] && val !== undefined) {
+        this.controls[key].patchValue(val);
+      }
+    }
+    this.markAsDirty();
+  }
+  reset() {
+    for (const ctrl of Object.values(this.controls)) {
+      ctrl.reset();
+    }
+    this.markAsPristine();
+    this.markAsUntouched();
+  }
+  updateValueAndValidity() {
+    if (this.disabled) {
+      this.setErrors(null);
+      return;
+    }
+    let hasInvalid = false;
+    let hasPending = false;
+    for (const ctrl of Object.values(this.controls)) {
+      if (ctrl.invalid)
+        hasInvalid = true;
+      if (ctrl.pending)
+        hasPending = true;
+    }
+    if (hasInvalid) {
+      this.setErrors({ invalidChildren: true });
+    } else if (hasPending) {
+      this._status = "PENDING";
+    } else {
+      super.updateValueAndValidity();
+    }
+  }
+}
+
+class FormArray extends AbstractControl {
+  controls;
+  constructor(controls = [], validatorOrOpts, asyncValidator) {
+    super(validatorOrOpts, asyncValidator);
+    this.controls = controls;
+    for (const ctrl of controls) {
+      ctrl.setParent(this);
+    }
+    this.updateValueAndValidity();
+  }
+  get length() {
+    return this.controls.length;
+  }
+  at(index) {
+    return this.controls[index] ?? null;
+  }
+  push(control) {
+    this.controls.push(control);
+    control.setParent(this);
+    this.updateValueAndValidity();
+  }
+  insert(index, control) {
+    this.controls.splice(index, 0, control);
+    control.setParent(this);
+    this.updateValueAndValidity();
+  }
+  removeAt(index) {
+    if (index >= 0 && index < this.controls.length) {
+      this.controls[index].setParent(null);
+      this.controls.splice(index, 1);
+      this.updateValueAndValidity();
+    }
+  }
+  clear() {
+    for (const ctrl of this.controls) {
+      ctrl.setParent(null);
+    }
+    this.controls.length = 0;
+    this.updateValueAndValidity();
+  }
+  get value() {
+    return this.controls.map((c) => c.value);
+  }
+  setValue(value) {
+    value.forEach((val, i) => {
+      if (this.controls[i])
+        this.controls[i].setValue(val);
+    });
+    this.markAsDirty();
+  }
+  patchValue(value) {
+    value.forEach((val, i) => {
+      if (this.controls[i] && val !== undefined)
+        this.controls[i].patchValue(val);
+    });
+    this.markAsDirty();
+  }
+  reset() {
+    for (const ctrl of this.controls)
+      ctrl.reset();
+    this.markAsPristine();
+    this.markAsUntouched();
+  }
+  updateValueAndValidity() {
+    if (this.disabled) {
+      this.setErrors(null);
+      return;
+    }
+    let hasInvalid = false;
+    let hasPending = false;
+    for (const ctrl of this.controls) {
+      if (ctrl.invalid)
+        hasInvalid = true;
+      if (ctrl.pending)
+        hasPending = true;
+    }
+    if (hasInvalid) {
+      this.setErrors({ invalidChildren: true });
+    } else if (hasPending) {
+      this._status = "PENDING";
+    } else {
+      super.updateValueAndValidity();
+    }
+  }
+}
+
+class Validators {
+  static nullValidator(_control) {
+    return null;
+  }
+  static required(control) {
+    const val = control.value;
+    if (val === null || val === undefined || val === "" || Array.isArray(val) && val.length === 0) {
+      return { required: true };
+    }
+    return null;
+  }
+  static requiredTrue(control) {
+    return control.value === true ? null : { required: true };
+  }
+  static min(min) {
+    return (control) => {
+      const val = control.value;
+      if (val === null || val === undefined || val === "")
+        return null;
+      const num = Number(val);
+      return !Number.isNaN(num) && num < min ? { min: { min, actual: val } } : null;
+    };
+  }
+  static max(max) {
+    return (control) => {
+      const val = control.value;
+      if (val === null || val === undefined || val === "")
+        return null;
+      const num = Number(val);
+      return !Number.isNaN(num) && num > max ? { max: { max, actual: val } } : null;
+    };
+  }
+  static minLength(minLength) {
+    return (control) => {
+      const val = control.value;
+      if (val === null || val === undefined)
+        return null;
+      const length = typeof val === "string" || Array.isArray(val) ? val.length : 0;
+      return length < minLength ? { minlength: { requiredLength: minLength, actualLength: length } } : null;
+    };
+  }
+  static maxLength(maxLength) {
+    return (control) => {
+      const val = control.value;
+      if (val === null || val === undefined)
+        return null;
+      const length = typeof val === "string" || Array.isArray(val) ? val.length : 0;
+      return length > maxLength ? { maxlength: { requiredLength: maxLength, actualLength: length } } : null;
+    };
+  }
+  static email(control) {
+    const val = control.value;
+    if (!val)
+      return null;
+    const emailRegex = /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;
+    return typeof val === "string" && emailRegex.test(val) ? null : { email: true };
+  }
+  static pattern(pattern) {
+    const regex = typeof pattern === "string" ? new RegExp(`^${pattern}$`) : pattern;
+    return (control) => {
+      const val = control.value;
+      if (!val)
+        return null;
+      return regex.test(String(val)) ? null : { pattern: { requiredPattern: String(pattern), actualValue: val } };
+    };
+  }
+  static compose(validators) {
+    if (!validators)
+      return null;
+    const present = validators.filter((v) => typeof v === "function");
+    if (present.length === 0)
+      return null;
+    return (control) => {
+      const errors = {};
+      let hasErrors = false;
+      for (const fn of present) {
+        const err = fn(control);
+        if (err) {
+          Object.assign(errors, err);
+          hasErrors = true;
+        }
+      }
+      return hasErrors ? errors : null;
+    };
+  }
+  static composeAsync(validators) {
+    if (!validators)
+      return null;
+    const present = validators.filter((v) => typeof v === "function");
+    if (present.length === 0)
+      return null;
+    return async (control) => {
+      const results = await Promise.all(present.map((fn) => fn(control)));
+      const errors = {};
+      let hasErrors = false;
+      for (const err of results) {
+        if (err) {
+          Object.assign(errors, err);
+          hasErrors = true;
+        }
+      }
+      return hasErrors ? errors : null;
+    };
+  }
+}
+// src/input_transform.ts
+function booleanAttribute(value) {
+  if (typeof value === "boolean") {
+    return value;
+  }
+  if (value === null || value === undefined) {
+    return false;
+  }
+  if (typeof value === "string") {
+    return value !== "false";
+  }
+  return Boolean(value);
+}
+function numberAttribute(value, fallbackValue = NaN) {
+  const isNumber = typeof value === "number";
+  const isString = typeof value === "string";
+  if (!isNumber && !isString) {
+    return fallbackValue;
+  }
+  const parsed = isNumber ? value : parseFloat(value);
+  return isNaN(parsed) ? fallbackValue : parsed;
+}
+// src/pipe.ts
+var PIPE_METADATA_KEY = Symbol.for("supacloud.pipe");
+function Pipe(options) {
+  return (target) => {
+    const meta = {
+      pure: true,
+      standalone: true,
+      ...options
+    };
+    if (typeof Reflect !== "undefined" && typeof Reflect.defineMetadata === "function") {
+      Reflect.defineMetadata(PIPE_METADATA_KEY, meta, target);
+    }
+    target[PIPE_METADATA_KEY] = meta;
+  };
+}
+function getPipeMetadata(target) {
+  if (!target)
+    return;
+  if (typeof Reflect !== "undefined" && typeof Reflect.getMetadata === "function") {
+    const meta = Reflect.getMetadata(PIPE_METADATA_KEY, target);
+    if (meta)
+      return meta;
+  }
+  return target[PIPE_METADATA_KEY];
+}
+
+class UpperCasePipe {
+  transform(value) {
+    return value != null ? String(value).toUpperCase() : "";
+  }
+}
+UpperCasePipe = __legacyDecorateClassTS([
+  Pipe({ name: "uppercase", pure: true })
+], UpperCasePipe);
+
+class LowerCasePipe {
+  transform(value) {
+    return value != null ? String(value).toLowerCase() : "";
+  }
+}
+LowerCasePipe = __legacyDecorateClassTS([
+  Pipe({ name: "lowercase", pure: true })
+], LowerCasePipe);
+
+class TrimPipe {
+  transform(value) {
+    return value != null ? String(value).trim() : "";
+  }
+}
+TrimPipe = __legacyDecorateClassTS([
+  Pipe({ name: "trim", pure: true })
+], TrimPipe);
+
+class JsonPipe {
+  transform(value, space = 2) {
+    return JSON.stringify(value, null, space);
+  }
+}
+JsonPipe = __legacyDecorateClassTS([
+  Pipe({ name: "json", pure: true })
+], JsonPipe);
+
+class DatePipe {
+  transform(value, format = "iso") {
+    if (!value)
+      return "";
+    const d = new Date(value);
+    if (isNaN(d.getTime()))
+      return "";
+    return format === "iso" ? d.toISOString() : d.toLocaleString();
+  }
+}
+DatePipe = __legacyDecorateClassTS([
+  Pipe({ name: "date", pure: true })
+], DatePipe);
 export {
+  APP_BASE_HREF,
+  APP_INITIALIZER,
+  AbstractControl,
+  Body,
+  CAN_DEACTIVATE_METADATA,
   COMMAND_METADATA,
   CONTROLLER_METADATA,
+  CanDeactivate,
   Command,
   Controller,
   DB_CLIENT,
   DEFAULT_SCOPE,
+  DESTROY_REF,
+  DOCUMENT,
+  Data,
+  DatePipe,
+  DefaultTitleStrategy,
+  DefaultUrlSerializer,
   Delete,
+  ENVIRONMENT_INITIALIZER,
+  FormArray,
+  FormControl,
+  FormGroup,
+  GUARDS_METADATA,
   Get,
+  HOST_PARAMS_METADATA,
+  HTTP_CLIENT_CONFIG,
+  HTTP_INTERCEPTORS,
   Head,
+  Headers,
+  Host,
+  HttpClient,
+  HttpContext,
+  HttpContextToken,
+  HttpErrorResponse,
+  HttpHeaders,
+  HttpParams,
   INJECTABLE_METADATA,
+  INJECTOR,
   INJECT_PARAMS_METADATA,
   Inject,
   Injectable,
   InjectionToken,
   JOB_CONTEXT,
+  JsonPipe,
+  LowerCasePipe,
   MODULE_METADATA,
   Module,
+  OPTIONAL_PARAMS_METADATA,
+  Optional,
   Options,
+  PLATFORM_BROWSER_ID,
+  PLATFORM_EDGE_ID,
+  PLATFORM_ID,
+  PLATFORM_SERVER_ID,
+  Param,
   Patch,
+  Pipe,
   Post,
   Put,
   QUERY_METADATA,
   Query,
   REQUEST_CONTEXT,
+  RESOLVE_METADATA,
+  ROUTER_CONFIGURATION,
   ROUTES_METADATA,
+  ROUTE_CONFIG,
+  ROUTE_PARAMS_METADATA,
+  RedirectCommand,
+  Resolve,
   SCOPES,
   SCOPE_LIFETIME_RANK,
+  SELF_PARAMS_METADATA,
+  SKIP_SELF_PARAMS_METADATA,
+  Self,
+  SkipSelf,
+  TITLE_STRATEGY,
+  TRANSFER_STATE,
+  TestBed,
+  Title,
+  TitleStrategy,
+  TransferState,
+  TrimPipe,
+  UpperCasePipe,
+  UrlSegmentGroup,
+  UrlSerializer,
+  UrlTree,
+  UseGuards,
+  Validators,
+  assertInInjectionContext,
+  booleanAttribute,
+  computed,
+  createBearerAuthInterceptor,
+  createChildInjector,
+  createDestroyRef,
+  createEnvironmentInjector,
+  createHeaderInterceptor,
+  createRetryInterceptor,
+  createTimeoutInterceptor,
   defineModule,
+  detectPlatform,
+  effect,
+  executeResolvers,
+  executeRoutePipeline,
+  flattenProviders,
+  forwardRef,
+  getActiveInjector,
   getCommandMeta,
   getControllerMeta,
+  getGuards,
+  getHostParams,
   getInjectParams,
   getInjectableMeta,
   getModuleMeta,
+  getOptionalParams,
+  getPipeMetadata,
   getQueryMeta,
+  getRouteParams,
   getRoutes,
+  getSelfParams,
+  getSkipSelfParams,
+  inject,
+  injectAll,
+  injectDestroySignal,
   isClassProvider,
+  isEnvironmentProviders,
   isExistingProvider,
   isFactoryProvider,
+  isForwardRef,
+  isPlatformBrowser,
+  isPlatformEdge,
+  isPlatformServer,
+  isRedirectCommand,
   isScopeViolation,
-  isValueProvider
+  isValueProvider,
+  joinWithSlash,
+  linkedSignal,
+  makeEnvironmentProviders,
+  makeStateKey,
+  matchRoute,
+  normalizePath,
+  numberAttribute,
+  provideAppInitializer,
+  provideEnvironmentInitializer,
+  provideHttpClient,
+  provideRouter,
+  provideToken,
+  resolveForwardRef,
+  resource,
+  runInInjectionContext,
+  signal,
+  stripTrailingSlash,
+  untracked,
+  withComponentInputBinding,
+  withFetch,
+  withInterceptors,
+  withRequestsMadeViaParent,
+  withRouterConfig,
+  withTitleStrategy
 };