@geekmidas/cli 10.0.0-alpha.44 → 10.0.0-alpha.46

package/dist/reconcile/public.cjs

@@ -1,9 +1,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_discover = require("../discover-B0f_kuNN.cjs");
-const require_emit = require("../emit-BdoPFjZf.cjs");
-exports.MANIFEST_PATH = require_emit.MANIFEST_PATH;
+const require_discover = require("../discover-DXNviAh-.cjs");
+const require_emit = require("../emit-Dmc1nvdS.cjs");
 exports.discover = require_discover.discover;
 exports.isDeclarable = require_discover.isDeclarable;
 exports.manifestModule = require_emit.manifestModule;
 exports.withRoutes = require_emit.withRoutes;
-exports.writeManifestModule = require_emit.writeManifestModule;

package/dist/reconcile/public.d.cts

@@ -1,4 +1,4 @@
-import { n as EmailBackend, t as CacheBackend } from "../types-DfdYe31u.cjs";
+import { n as EmailBackend, t as CacheBackend } from "../types-DNqEsctD.cjs";
 import { ConstructManifest, Declaration, RouteInfo } from "@geekmidas/manifest";
 //#region src/reconcile/discover.d.ts
 /** The construct face discovery needs: an id, and the ability to declare. */
@@ -75,8 +75,6 @@ interface ConstructSource {
 export declare function discover(options: DiscoverOptions): Promise<ConstructManifest>;
 //#endregion
 //#region src/reconcile/emit.d.ts
-/** Where the build writes it, relative to the app root. */
-export declare const MANIFEST_PATH = ".gkm/manifest.ts";
 /**
  * Fold the build's generated routes into the surface that serves them.
  *
@@ -91,11 +89,10 @@ export declare const MANIFEST_PATH = ".gkm/manifest.ts";
  * already knows where it wrote each handler. Asking the declaration to restate
  * any of that is how the two come to disagree.
  *
- * Attribution is by exclusion — routes go to the surface that declared none of
- * its own. A surface with static endpoints (an auth server's single wildcard)
- * keeps them. That is exact while an app has one API of its own, and needs a
- * real answer the day it has two; the alternative today would be inventing one
- * before anything needs it.
+ * Attribution is to the surface the build served — the one whose `path` is
+ * the app being built. Without one, routes go to the surface that declared none
+ * of its own; a surface with static endpoints (an auth server's single
+ * wildcard) keeps them.
  *
  * **Only from a provider that generates one handler per route.** The `server`
  * provider generates a single catch-all — `ALL *` pointing at the Hono app that
@@ -107,6 +104,7 @@ export declare const MANIFEST_PATH = ".gkm/manifest.ts";
  */
 export declare function withRoutes(manifest: ConstructManifest, routes: readonly RouteInfo[], options: {
   perRoute: boolean;
+  surface?: string;
 }): ConstructManifest;
 /**
  * The manifest as TypeScript source.
@@ -114,8 +112,6 @@ export declare function withRoutes(manifest: ConstructManifest, routes: readonly
  * Pure, so what gets written can be asserted without touching a filesystem.
  */
 export declare function manifestModule(manifest: ConstructManifest, backends?: Backends): string;
-/** Write it where the deploy config expects to import it from. */
-export declare function writeManifestModule(manifest: ConstructManifest, appRoot: string, backends?: Backends): Promise<string>;
 /** The choices that are deployment config rather than declaration. */
 interface Backends {
   cache?: CacheBackend;

package/dist/reconcile/public.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"public.d.cts","names":[],"sources":["../../src/reconcile/discover.ts","../../src/reconcile/emit.ts"],"mappings":";;;;UA8BU;EACT;EACA,WAAW;;;;;;;;;wBAUI,aAAa,iBAAiB,SAAS;UAYtC;;EAEhB;EACA;;;;;;;EAOA;;;;;;;;;;;;EAYA,UAAU,eAAe;;;;;;;;;;;;EAYzB,YAAY;;;UAII;;EAEhB;;EAEA;;;;;;;EAOA;;;;;;;;;;wBAWqB,SACrB,SAAS,kBACP,QAAQ;;;;qBC/EE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA8BG,WACf,UAAU,mBACV,iBAAiB,aACjB;EAAW;IACT;;;;;;wBA2Ja,eACf,UAAU,mBACV,WAAU;;wBA8BW,oBACrB,UAAU,mBACV,iBACA,WAAU,WACR;;UAUc;EAChB,QAAQ;EACR,QAAQ"}
+{"version":3,"file":"public.d.cts","names":[],"sources":["../../src/reconcile/discover.ts","../../src/reconcile/emit.ts"],"mappings":";;;;UA8BU;EACT;EACA,WAAW;;;;;;;;;wBAUI,aAAa,iBAAiB,SAAS;UAYtC;;EAEhB;EACA;;;;;;;EAOA;;;;;;;;;;;;EAYA,UAAU,eAAe;;;;;;;;;;;;EAYzB,YAAY;;;UAII;;EAEhB;;EAEA;;;;;;;EAOA;;;;;;;;;;wBAWqB,SACrB,SAAS,kBACP,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBCvDK,WACf,UAAU,mBACV,iBAAiB,aACjB;EAAW;EAAmB;IAC5B;;;;;;wBA4Ja,eACf,UAAU,mBACV,WAAU;;UA8BM;EAChB,QAAQ;EACR,QAAQ"}

package/dist/reconcile/public.d.mts

@@ -1,4 +1,4 @@
-import { n as EmailBackend, t as CacheBackend } from "../types-0R124hrY.mjs";
+import { n as EmailBackend, t as CacheBackend } from "../types-BbrNu83u.mjs";
 import { ConstructManifest, Declaration, RouteInfo } from "@geekmidas/manifest";
 //#region src/reconcile/discover.d.ts
 /** The construct face discovery needs: an id, and the ability to declare. */
@@ -75,8 +75,6 @@ interface ConstructSource {
 export declare function discover(options: DiscoverOptions): Promise<ConstructManifest>;
 //#endregion
 //#region src/reconcile/emit.d.ts
-/** Where the build writes it, relative to the app root. */
-export declare const MANIFEST_PATH = ".gkm/manifest.ts";
 /**
  * Fold the build's generated routes into the surface that serves them.
  *
@@ -91,11 +89,10 @@ export declare const MANIFEST_PATH = ".gkm/manifest.ts";
  * already knows where it wrote each handler. Asking the declaration to restate
  * any of that is how the two come to disagree.
  *
- * Attribution is by exclusion — routes go to the surface that declared none of
- * its own. A surface with static endpoints (an auth server's single wildcard)
- * keeps them. That is exact while an app has one API of its own, and needs a
- * real answer the day it has two; the alternative today would be inventing one
- * before anything needs it.
+ * Attribution is to the surface the build served — the one whose `path` is
+ * the app being built. Without one, routes go to the surface that declared none
+ * of its own; a surface with static endpoints (an auth server's single
+ * wildcard) keeps them.
  *
  * **Only from a provider that generates one handler per route.** The `server`
  * provider generates a single catch-all — `ALL *` pointing at the Hono app that
@@ -107,6 +104,7 @@ export declare const MANIFEST_PATH = ".gkm/manifest.ts";
  */
 export declare function withRoutes(manifest: ConstructManifest, routes: readonly RouteInfo[], options: {
   perRoute: boolean;
+  surface?: string;
 }): ConstructManifest;
 /**
  * The manifest as TypeScript source.
@@ -114,8 +112,6 @@ export declare function withRoutes(manifest: ConstructManifest, routes: readonly
  * Pure, so what gets written can be asserted without touching a filesystem.
  */
 export declare function manifestModule(manifest: ConstructManifest, backends?: Backends): string;
-/** Write it where the deploy config expects to import it from. */
-export declare function writeManifestModule(manifest: ConstructManifest, appRoot: string, backends?: Backends): Promise<string>;
 /** The choices that are deployment config rather than declaration. */
 interface Backends {
   cache?: CacheBackend;

package/dist/reconcile/public.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"public.d.mts","names":[],"sources":["../../src/reconcile/discover.ts","../../src/reconcile/emit.ts"],"mappings":";;;;UA8BU;EACT;EACA,WAAW;;;;;;;;;wBAUI,aAAa,iBAAiB,SAAS;UAYtC;;EAEhB;EACA;;;;;;;EAOA;;;;;;;;;;;;EAYA,UAAU,eAAe;;;;;;;;;;;;EAYzB,YAAY;;;UAII;;EAEhB;;EAEA;;;;;;;EAOA;;;;;;;;;;wBAWqB,SACrB,SAAS,kBACP,QAAQ;;;;qBC/EE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA8BG,WACf,UAAU,mBACV,iBAAiB,aACjB;EAAW;IACT;;;;;;wBA2Ja,eACf,UAAU,mBACV,WAAU;;wBA8BW,oBACrB,UAAU,mBACV,iBACA,WAAU,WACR;;UAUc;EAChB,QAAQ;EACR,QAAQ"}
+{"version":3,"file":"public.d.mts","names":[],"sources":["../../src/reconcile/discover.ts","../../src/reconcile/emit.ts"],"mappings":";;;;UA8BU;EACT;EACA,WAAW;;;;;;;;;wBAUI,aAAa,iBAAiB,SAAS;UAYtC;;EAEhB;EACA;;;;;;;EAOA;;;;;;;;;;;;EAYA,UAAU,eAAe;;;;;;;;;;;;EAYzB,YAAY;;;UAII;;EAEhB;;EAEA;;;;;;;EAOA;;;;;;;;;;wBAWqB,SACrB,SAAS,kBACP,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBCvDK,WACf,UAAU,mBACV,iBAAiB,aACjB;EAAW;EAAmB;IAC5B;;;;;;wBA4Ja,eACf,UAAU,mBACV,WAAU;;UA8BM;EAChB,QAAQ;EACR,QAAQ"}

package/dist/reconcile/public.mjs

@@ -1,3 +1,3 @@
-import { r as isDeclarable, t as discover } from "../discover-BLhf7V_J.mjs";
-import { a as writeManifestModule, i as withRoutes, n as manifestModule, t as MANIFEST_PATH } from "../emit-Bzq7JsMP.mjs";
-export { MANIFEST_PATH, discover, isDeclarable, manifestModule, withRoutes, writeManifestModule };
+import { r as isDeclarable, t as discover } from "../discover-Cf2jAcgF.mjs";
+import { r as withRoutes, t as manifestModule } from "../emit-C1e8qD08.mjs";
+export { discover, isDeclarable, manifestModule, withRoutes };

package/dist/{types-0R124hrY.d.mts → types-BbrNu83u.d.mts}

@@ -4618,7 +4618,7 @@ type Framework = output$1<typeof FrameworkSchema>;
 /**
  * Supported deploy targets (Phase 1).
  */
-declare const SUPPORTED_DEPLOY_TARGETS: readonly ['dokploy'];
+declare const SUPPORTED_DEPLOY_TARGETS: readonly ['dokploy', 'sst'];
 /**
  * Phase 2 deploy targets (not yet implemented).
  */
@@ -4798,10 +4798,7 @@ type BackupsConfig = output$1<typeof BackupsConfigSchema>;
  */
 declare const WorkspaceConfigSchema: ZodObject<{
   name: ZodOptional<ZodString>;
-  constructs: ZodOptional<ZodUnion<readonly [ZodString, ZodArray<ZodString>, ZodObject<{
-    paths: ZodUnion<readonly [ZodString, ZodArray<ZodString>]>;
-    partition: ZodCustom<(filepath: string) => string, (filepath: string) => string>;
-  }, $strip>]>>;
+  constructs: ZodOptional<ZodUnion<readonly [ZodString, ZodArray<ZodString>]>>;
   apps: ZodOptional<ZodRecord<ZodString, ZodObject<{
     type: ZodDefault<ZodOptional<ZodEnum<{
       backend: "backend";
@@ -4814,36 +4811,16 @@ declare const WorkspaceConfigSchema: ZodObject<{
     deploy: ZodOptional<ZodEnum<{
       cloudflare: "cloudflare";
       dokploy: "dokploy";
+      sst: "sst";
       vercel: "vercel";
     }>>;
-    constructs: ZodOptional<ZodUnion<readonly [ZodString, ZodArray<ZodString>, ZodObject<{
-      paths: ZodUnion<readonly [ZodString, ZodArray<ZodString>]>;
-      partition: ZodCustom<(filepath: string) => string, (filepath: string) => string>;
-    }, $strip>]>>;
-    routes: ZodOptional<ZodUnion<readonly [ZodString, ZodArray<ZodString>, ZodObject<{
-      paths: ZodUnion<readonly [ZodString, ZodArray<ZodString>]>;
-      partition: ZodCustom<(filepath: string) => string, (filepath: string) => string>;
-    }, $strip>]>>;
-    functions: ZodOptional<ZodUnion<readonly [ZodString, ZodArray<ZodString>, ZodObject<{
-      paths: ZodUnion<readonly [ZodString, ZodArray<ZodString>]>;
-      partition: ZodCustom<(filepath: string) => string, (filepath: string) => string>;
-    }, $strip>]>>;
-    crons: ZodOptional<ZodUnion<readonly [ZodString, ZodArray<ZodString>, ZodObject<{
-      paths: ZodUnion<readonly [ZodString, ZodArray<ZodString>]>;
-      partition: ZodCustom<(filepath: string) => string, (filepath: string) => string>;
-    }, $strip>]>>;
-    queues: ZodOptional<ZodUnion<readonly [ZodString, ZodArray<ZodString>, ZodObject<{
-      paths: ZodUnion<readonly [ZodString, ZodArray<ZodString>]>;
-      partition: ZodCustom<(filepath: string) => string, (filepath: string) => string>;
-    }, $strip>]>>;
-    topics: ZodOptional<ZodUnion<readonly [ZodString, ZodArray<ZodString>, ZodObject<{
-      paths: ZodUnion<readonly [ZodString, ZodArray<ZodString>]>;
-      partition: ZodCustom<(filepath: string) => string, (filepath: string) => string>;
-    }, $strip>]>>;
-    subscribers: ZodOptional<ZodUnion<readonly [ZodString, ZodArray<ZodString>, ZodObject<{
-      paths: ZodUnion<readonly [ZodString, ZodArray<ZodString>]>;
-      partition: ZodCustom<(filepath: string) => string, (filepath: string) => string>;
-    }, $strip>]>>;
+    constructs: ZodOptional<ZodUnion<readonly [ZodString, ZodArray<ZodString>]>>;
+    routes: ZodOptional<ZodUnion<readonly [ZodString, ZodArray<ZodString>]>>;
+    functions: ZodOptional<ZodUnion<readonly [ZodString, ZodArray<ZodString>]>>;
+    crons: ZodOptional<ZodUnion<readonly [ZodString, ZodArray<ZodString>]>>;
+    queues: ZodOptional<ZodUnion<readonly [ZodString, ZodArray<ZodString>]>>;
+    topics: ZodOptional<ZodUnion<readonly [ZodString, ZodArray<ZodString>]>>;
+    subscribers: ZodOptional<ZodUnion<readonly [ZodString, ZodArray<ZodString>]>>;
     envParser: ZodOptional<ZodString>;
     logger: ZodOptional<ZodString>;
     hooks: ZodOptional<ZodObject<{
@@ -4906,6 +4883,7 @@ declare const WorkspaceConfigSchema: ZodObject<{
     default: ZodOptional<ZodEnum<{
       cloudflare: "cloudflare";
       dokploy: "dokploy";
+      sst: "sst";
       vercel: "vercel";
     }>>;
     dokploy: ZodOptional<ZodObject<{
@@ -5199,7 +5177,7 @@ declare function formatValidationErrors(error: ZodError): string;
  * deploy: 'cloudflare'
  * ```
  */
-type DeployTarget = 'dokploy' | 'vercel' | 'cloudflare';
+type DeployTarget = 'dokploy' | 'sst' | 'vercel' | 'cloudflare';
 /**
  * Stage-based domain configuration.
  *
@@ -5554,8 +5532,6 @@ interface AppConfigBase {
    * @example './src/config/logger'
    */
   logger?: string;
-  /** Provider configuration (AWS, Docker, etc.) */
-  providers?: ProvidersConfig;
   /**
    * Server lifecycle hooks.
    * @example { beforeSetup: './src/hooks/setup.ts' }
@@ -6009,43 +5985,7 @@ interface LoadedConfig {
 declare function isWorkspaceConfig(config: GkmConfig | WorkspaceConfig): config is WorkspaceConfig;
 //#endregion
 //#region src/types.d.ts
-interface PartitionedRoutes {
-  paths: string | string[];
-  partition: (filepath: string) => string;
-}
-type Routes = string | string[] | PartitionedRoutes;
-interface ProviderConfig {
-  enabled?: boolean;
-  outputDir?: string;
-}
-interface AWSApiGatewayConfig extends ProviderConfig {}
-interface AWSLambdaConfig extends ProviderConfig {}
-interface ProductionConfig {
-  /** Enable production mode (default: false) */
-  enabled?: boolean;
-  /** Bundle server into single file (default: true) */
-  bundle?: boolean;
-  /** Minify bundled output (default: true) */
-  minify?: boolean;
-  /** Health check endpoint path (default: '/health') */
-  healthCheck?: string;
-  /** Enable graceful shutdown handling (default: true) */
-  gracefulShutdown?: boolean;
-  /** Packages to exclude from bundling (default: []) */
-  external?: string[];
-  /** Include subscribers in production build (default: 'exclude' for serverless) */
-  subscribers?: 'include' | 'exclude';
-  /** Include OpenAPI spec in production (default: false) */
-  openapi?: boolean;
-  /**
-   * Enable build-time optimized handler generation (default: true)
-   * Generates specialized handlers based on endpoint tier:
-   * - minimal: Near-raw-Hono performance for simple endpoints
-   * - standard: Optimized handlers for auth/services
-   * - full: Uses HonoEndpoint.addRoutes for complex endpoints
-   */
-  optimizedHandlers?: boolean;
-}
+type Routes = string | string[];
 /**
  * Where a declared cache actually lives.
  *
@@ -6095,12 +6035,6 @@ interface DockerConfig {
   /** Container port (default: 3000) */
   port?: number;
 }
-interface ServerConfig extends ProviderConfig {
-  enableOpenApi?: boolean;
-  port?: number;
-  /** Production build configuration */
-  production?: ProductionConfig;
-}
 type Runtime = 'node' | 'bun';
 interface TelescopeConfig {
   /** Enable/disable telescope (default: true in development) */
@@ -6163,34 +6097,6 @@ interface HooksConfig {
    */
   server?: string;
 }
-/** Dokploy deployment configuration */
-interface DokployProviderConfig {
-  /** Dokploy API endpoint (e.g., 'https://dokploy.example.com') */
-  endpoint: string;
-  /** Project ID in Dokploy */
-  projectId: string;
-  /** Application ID in Dokploy */
-  applicationId: string;
-  /** Container registry (overrides docker.registry if set) */
-  registry?: string;
-  /** Registry ID in Dokploy (recommended for private registries) */
-  registryId?: string;
-}
-interface ProvidersConfig {
-  aws?: {
-    apiGateway?: {
-      v1?: boolean | AWSApiGatewayConfig;
-      v2?: boolean | AWSApiGatewayConfig;
-    };
-    lambda?: {
-      functions?: boolean | AWSLambdaConfig;
-      crons?: boolean | AWSLambdaConfig;
-    };
-  };
-  server?: boolean | ServerConfig;
-  /** Dokploy deployment configuration */
-  dokploy?: boolean | DokployProviderConfig;
-}
 interface GkmConfig {
   /**
    * What this app is called, and therefore how everything it declares is named.
@@ -6227,7 +6133,6 @@ interface GkmConfig {
    * @example './src/**\/*.ts'
    */
   constructs: Routes;
-  providers?: ProvidersConfig;
   /**
    * Server lifecycle hooks for customizing the Hono app.
    * Allows adding custom routes, middleware, error handlers, etc.
@@ -6321,4 +6226,4 @@ interface GkmConfig {
 }
 //#endregion
 export { SUPPORTED_DEPLOY_TARGETS as A, WorkspaceInput as C, FrontendFramework as D, Framework as E, isPhase2DeployTarget as F, safeValidateWorkspaceConfig as I, validateWorkspaceConfig as L, formatValidationErrors as M, getDeployTargetError as N, MobileFramework as O, isDeployTargetSupported as P, WorkspaceConfig as S, BackendFramework as T, ModelsConfig as _, Routes as a, SecretsConfig as b, AppInput as c, DeployConfig as d, DeployTarget as f, LoadedConfig as g, InferredWorkspaceConfig as h, OpenApiConfig as i, WorkspaceConfigSchema as j, PHASE_2_DEPLOY_TARGETS as k, AppsRecord as l, InferAppNames as m, EmailBackend as n, AppConfig as o, DokployWorkspaceConfig as p, GkmConfig as r, AppConfigInput as s, CacheBackend as t, ConstrainedApps as u, NormalizedAppConfig as v, isWorkspaceConfig as w, SharedConfig as x, NormalizedWorkspace as y };
-//# sourceMappingURL=types-0R124hrY.d.mts.map
+//# sourceMappingURL=types-BbrNu83u.d.mts.map