@wopr-network/platform-core 1.58.0 → 1.59.0

package/dist/db/schema/product-config.js

@@ -0,0 +1,51 @@
+import { boolean, integer, jsonb, numeric, pgEnum, pgTable, text, timestamp, uuid } from "drizzle-orm/pg-core";
+import { products } from "./products.js";
+export const fleetLifecycleEnum = pgEnum("fleet_lifecycle", ["managed", "ephemeral"]);
+export const fleetBillingModelEnum = pgEnum("fleet_billing_model", ["monthly", "per_use", "none"]);
+export const productFeatures = pgTable("product_features", {
+    productId: uuid("product_id")
+        .primaryKey()
+        .references(() => products.id, { onDelete: "cascade" }),
+    chatEnabled: boolean("chat_enabled").notNull().default(true),
+    onboardingEnabled: boolean("onboarding_enabled").notNull().default(true),
+    onboardingDefaultModel: text("onboarding_default_model"),
+    onboardingSystemPrompt: text("onboarding_system_prompt"),
+    onboardingMaxCredits: integer("onboarding_max_credits").notNull().default(100),
+    onboardingWelcomeMsg: text("onboarding_welcome_msg"),
+    sharedModuleBilling: boolean("shared_module_billing").notNull().default(true),
+    sharedModuleMonitoring: boolean("shared_module_monitoring").notNull().default(true),
+    sharedModuleAnalytics: boolean("shared_module_analytics").notNull().default(true),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+});
+export const productFleetConfig = pgTable("product_fleet_config", {
+    productId: uuid("product_id")
+        .primaryKey()
+        .references(() => products.id, { onDelete: "cascade" }),
+    containerImage: text("container_image").notNull(),
+    containerPort: integer("container_port").notNull().default(3100),
+    lifecycle: fleetLifecycleEnum("lifecycle").notNull().default("managed"),
+    billingModel: fleetBillingModelEnum("billing_model").notNull().default("monthly"),
+    maxInstances: integer("max_instances").notNull().default(5),
+    imageAllowlist: text("image_allowlist").array(),
+    dockerNetwork: text("docker_network").notNull().default(""),
+    placementStrategy: text("placement_strategy").notNull().default("least-loaded"),
+    fleetDataDir: text("fleet_data_dir").notNull().default("/data/fleet"),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+});
+export const productBillingConfig = pgTable("product_billing_config", {
+    productId: uuid("product_id")
+        .primaryKey()
+        .references(() => products.id, { onDelete: "cascade" }),
+    stripePublishableKey: text("stripe_publishable_key"),
+    /** Encrypted via credential vault (CRYPTO_SERVICE_KEY) before storage. */
+    stripeSecretKey: text("stripe_secret_key"),
+    /** Encrypted via credential vault (CRYPTO_SERVICE_KEY) before storage. */
+    stripeWebhookSecret: text("stripe_webhook_secret"),
+    creditPrices: jsonb("credit_prices").notNull().default({}),
+    affiliateBaseUrl: text("affiliate_base_url"),
+    affiliateMatchRate: numeric("affiliate_match_rate").notNull().default("1.0"),
+    affiliateMaxCap: integer("affiliate_max_cap").notNull().default(20000),
+    dividendRate: numeric("dividend_rate").notNull().default("1.0"),
+    marginConfig: jsonb("margin_config"),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+});

package/dist/db/schema/products.d.ts

@@ -0,0 +1,565 @@
+export declare const products: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "products";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "products";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        slug: import("drizzle-orm/pg-core").PgColumn<{
+            name: "slug";
+            tableName: "products";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        brandName: import("drizzle-orm/pg-core").PgColumn<{
+            name: "brand_name";
+            tableName: "products";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        productName: import("drizzle-orm/pg-core").PgColumn<{
+            name: "product_name";
+            tableName: "products";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        tagline: import("drizzle-orm/pg-core").PgColumn<{
+            name: "tagline";
+            tableName: "products";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        domain: import("drizzle-orm/pg-core").PgColumn<{
+            name: "domain";
+            tableName: "products";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        appDomain: import("drizzle-orm/pg-core").PgColumn<{
+            name: "app_domain";
+            tableName: "products";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        cookieDomain: import("drizzle-orm/pg-core").PgColumn<{
+            name: "cookie_domain";
+            tableName: "products";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        companyLegal: import("drizzle-orm/pg-core").PgColumn<{
+            name: "company_legal";
+            tableName: "products";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        priceLabel: import("drizzle-orm/pg-core").PgColumn<{
+            name: "price_label";
+            tableName: "products";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        defaultImage: import("drizzle-orm/pg-core").PgColumn<{
+            name: "default_image";
+            tableName: "products";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        emailSupport: import("drizzle-orm/pg-core").PgColumn<{
+            name: "email_support";
+            tableName: "products";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        emailPrivacy: import("drizzle-orm/pg-core").PgColumn<{
+            name: "email_privacy";
+            tableName: "products";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        emailLegal: import("drizzle-orm/pg-core").PgColumn<{
+            name: "email_legal";
+            tableName: "products";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        fromEmail: import("drizzle-orm/pg-core").PgColumn<{
+            name: "from_email";
+            tableName: "products";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        homePath: import("drizzle-orm/pg-core").PgColumn<{
+            name: "home_path";
+            tableName: "products";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        storagePrefix: import("drizzle-orm/pg-core").PgColumn<{
+            name: "storage_prefix";
+            tableName: "products";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "products";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updatedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "updated_at";
+            tableName: "products";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+export declare const productNavItems: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "product_nav_items";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "product_nav_items";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        productId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "product_id";
+            tableName: "product_nav_items";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        label: import("drizzle-orm/pg-core").PgColumn<{
+            name: "label";
+            tableName: "product_nav_items";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        href: import("drizzle-orm/pg-core").PgColumn<{
+            name: "href";
+            tableName: "product_nav_items";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        icon: import("drizzle-orm/pg-core").PgColumn<{
+            name: "icon";
+            tableName: "product_nav_items";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        sortOrder: import("drizzle-orm/pg-core").PgColumn<{
+            name: "sort_order";
+            tableName: "product_nav_items";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        requiresRole: import("drizzle-orm/pg-core").PgColumn<{
+            name: "requires_role";
+            tableName: "product_nav_items";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        enabled: import("drizzle-orm/pg-core").PgColumn<{
+            name: "enabled";
+            tableName: "product_nav_items";
+            dataType: "boolean";
+            columnType: "PgBoolean";
+            data: boolean;
+            driverParam: boolean;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "product_nav_items";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;
+export declare const productDomains: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "product_domains";
+    schema: undefined;
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "product_domains";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        productId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "product_id";
+            tableName: "product_domains";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        host: import("drizzle-orm/pg-core").PgColumn<{
+            name: "host";
+            tableName: "product_domains";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        role: import("drizzle-orm/pg-core").PgColumn<{
+            name: "role";
+            tableName: "product_domains";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;

package/dist/db/schema/products.js

@@ -0,0 +1,43 @@
+import { boolean, index, integer, pgTable, text, timestamp, uniqueIndex, uuid } from "drizzle-orm/pg-core";
+export const products = pgTable("products", {
+    id: uuid("id").primaryKey().defaultRandom(),
+    slug: text("slug").notNull(),
+    brandName: text("brand_name").notNull(),
+    productName: text("product_name").notNull(),
+    tagline: text("tagline").notNull().default(""),
+    domain: text("domain").notNull(),
+    appDomain: text("app_domain").notNull(),
+    cookieDomain: text("cookie_domain").notNull(),
+    companyLegal: text("company_legal").notNull().default(""),
+    priceLabel: text("price_label").notNull().default(""),
+    defaultImage: text("default_image").notNull().default(""),
+    emailSupport: text("email_support").notNull().default(""),
+    emailPrivacy: text("email_privacy").notNull().default(""),
+    emailLegal: text("email_legal").notNull().default(""),
+    fromEmail: text("from_email").notNull().default(""),
+    homePath: text("home_path").notNull().default("/marketplace"),
+    storagePrefix: text("storage_prefix").notNull(),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).notNull().defaultNow(),
+}, (t) => [uniqueIndex("products_slug_idx").on(t.slug)]);
+export const productNavItems = pgTable("product_nav_items", {
+    id: uuid("id").primaryKey().defaultRandom(),
+    productId: uuid("product_id")
+        .notNull()
+        .references(() => products.id, { onDelete: "cascade" }),
+    label: text("label").notNull(),
+    href: text("href").notNull(),
+    icon: text("icon"),
+    sortOrder: integer("sort_order").notNull(),
+    requiresRole: text("requires_role"),
+    enabled: boolean("enabled").notNull().default(true),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+}, (t) => [index("product_nav_items_product_sort_idx").on(t.productId, t.sortOrder)]);
+export const productDomains = pgTable("product_domains", {
+    id: uuid("id").primaryKey().defaultRandom(),
+    productId: uuid("product_id")
+        .notNull()
+        .references(() => products.id, { onDelete: "cascade" }),
+    host: text("host").notNull(),
+    role: text("role").notNull().default("canonical"),
+}, (t) => [uniqueIndex("product_domains_product_host_idx").on(t.productId, t.host)]);

package/dist/product-config/boot.d.ts

@@ -0,0 +1,36 @@
+import type { DrizzleDb } from "../db/index.js";
+import type { ProductConfig } from "./repository-types.js";
+import { ProductConfigService } from "./service.js";
+export interface PlatformBootResult {
+    /** The product config service — single point of access for config reads/writes. */
+    service: ProductConfigService;
+    /** The resolved product config (cached). */
+    config: ProductConfig;
+    /** CORS origins derived from product domains + optional dev origins. */
+    corsOrigins: string[];
+}
+export interface PlatformBootOptions {
+    /** Product slug (e.g. "paperclip", "wopr", "holyship", "nemoclaw"). */
+    slug: string;
+    /** Drizzle database instance. */
+    db: DrizzleDb;
+    /** Additional CORS origins for local dev (from DEV_ORIGINS env var). */
+    devOrigins?: string[];
+}
+/**
+ * Bootstrap product configuration from DB.
+ *
+ * Call once at startup, after DB + migrations, before route registration.
+ * Returns the service (for tRPC router wiring) and the resolved config
+ * (for CORS, email, fleet, auth initialization).
+ *
+ * This replaces: BRAND_NAME, PLATFORM_DOMAIN, UI_ORIGIN, FROM_EMAIL,
+ * SUPPORT_EMAIL, COOKIE_DOMAIN, APP_BASE_URL, and all other product-
+ * specific env vars that platform-core modules previously read from
+ * process.env.
+ *
+ * Product backends still own their specific wiring (crypto watchers,
+ * fleet updaters, notification pipelines). platformBoot handles the
+ * config-driven parts that are identical across products.
+ */
+export declare function platformBoot(opts: PlatformBootOptions): Promise<PlatformBootResult>;