@stardeck-customer-apps/compose 0.14.1 → 0.15.0

package/dist/index.js

@@ -1149,16 +1149,16 @@ var require_range = __commonJS({
     };
     var replaceTilde = (comp, options) => {
       const r = options.loose ? re[t.TILDELOOSE] : re[t.TILDE];
-      const z10 = options.includePrerelease ? "-0" : "";
+      const z11 = options.includePrerelease ? "-0" : "";
       return comp.replace(r, (_, M, m, p, pr) => {
         debug("tilde", comp, _, M, m, p, pr);
         let ret;
         if (isX(M)) {
           ret = "";
         } else if (isX(m)) {
-          ret = `>=${M}.0.0${z10} <${+M + 1}.0.0-0`;
+          ret = `>=${M}.0.0${z11} <${+M + 1}.0.0-0`;
         } else if (isX(p)) {
-          ret = `>=${M}.${m}.0${z10} <${M}.${+m + 1}.0-0`;
+          ret = `>=${M}.${m}.0${z11} <${M}.${+m + 1}.0-0`;
         } else if (pr) {
           debug("replaceTilde pr", pr);
           ret = `>=${M}.${m}.${p}-${pr} <${M}.${+m + 1}.0-0`;
@@ -1175,19 +1175,19 @@ var require_range = __commonJS({
     var replaceCaret = (comp, options) => {
       debug("caret", comp, options);
       const r = options.loose ? re[t.CARETLOOSE] : re[t.CARET];
-      const z10 = options.includePrerelease ? "-0" : "";
+      const z11 = options.includePrerelease ? "-0" : "";
       return comp.replace(r, (_, M, m, p, pr) => {
         debug("caret", comp, _, M, m, p, pr);
         let ret;
         if (isX(M)) {
           ret = "";
         } else if (isX(m)) {
-          ret = `>=${M}.0.0${z10} <${+M + 1}.0.0-0`;
+          ret = `>=${M}.0.0${z11} <${+M + 1}.0.0-0`;
         } else if (isX(p)) {
           if (M === "0") {
-            ret = `>=${M}.${m}.0${z10} <${M}.${+m + 1}.0-0`;
+            ret = `>=${M}.${m}.0${z11} <${M}.${+m + 1}.0-0`;
           } else {
-            ret = `>=${M}.${m}.0${z10} <${+M + 1}.0.0-0`;
+            ret = `>=${M}.${m}.0${z11} <${+M + 1}.0.0-0`;
           }
         } else if (pr) {
           debug("replaceCaret pr", pr);
@@ -4036,6 +4036,24 @@ function analyzeClientSafeEntryImports(sourceText, fileName) {
   return analyzeClientSafeEntryImportsWithTs(import_typescript3.default, sourceText, fileName);
 }
 
+// ../../packages/lib/src/shared/ownership-record.ts
+var import_zod7 = require("zod");
+var OWNERSHIP_RECORD_VERSION = 1;
+var moduleList = import_zod7.z.array(import_zod7.z.string().refine(isValidModuleName, "not a Module name"));
+var ownershipRecordSchema = import_zod7.z.object({
+  version: import_zod7.z.literal(OWNERSHIP_RECORD_VERSION),
+  /** False once the app stopped all Stardeck updates: then every file is the app's. */
+  stardeckUpdates: import_zod7.z.boolean(),
+  /** projects.ejected_modules: updates stopped for these Modules, so their folders are the app's. */
+  updatesStoppedModules: moduleList,
+  /** projects.ui_ejected_modules: Customize UI, so their screens are the app's. */
+  customizedUiModules: moduleList,
+  /** projects.external_modules: installed from another app, so the app owns the copy. */
+  externalModules: moduleList,
+  /** projects.removed_modules names: uninstalled on purpose. */
+  uninstalledModules: moduleList
+});
+
 // ../../packages/lib/src/shared/platform-owned-paths.ts
 var APP_WEB_PREFIX = "apps/web/";
 var BLUEPRINT_LINT_MARKER = `${APP_WEB_PREFIX}eslint-rules/module-boundaries.mjs`;
@@ -5990,14 +6008,14 @@ function rejectPseudoModuleEntries(entries, parentDir, label) {
 }
 
 // ../../packages/lib/src/shared/module-composition.ts
-var import_zod7 = require("zod");
-var creationSourceBlankSchema = import_zod7.z.object({
-  type: import_zod7.z.literal("blank")
+var import_zod8 = require("zod");
+var creationSourceBlankSchema = import_zod8.z.object({
+  type: import_zod8.z.literal("blank")
 });
-var creationSourceBlueprintSchema = import_zod7.z.object({
-  type: import_zod7.z.literal("blueprint"),
+var creationSourceBlueprintSchema = import_zod8.z.object({
+  type: import_zod8.z.literal("blueprint"),
   /** Internal template/fork project id — keep template naming in identifiers. */
-  blueprintProjectId: import_zod7.z.string().uuid(),
+  blueprintProjectId: import_zod8.z.string().uuid(),
   /**
    * `null`/absent means every feature Module: the platform stores that as the
    * explicit list of feature Modules in the published Blueprint version the fork
@@ -6005,192 +6023,197 @@ var creationSourceBlueprintSchema = import_zod7.z.object({
    * a custom app: no feature Module, Library Modules only (`resolvePlatformEnv`
    * emits it as a set value naming no Module).
    */
-  enabledModules: import_zod7.z.array(moduleNameSchema).max(100).nullable().optional()
+  enabledModules: import_zod8.z.array(moduleNameSchema).max(100).nullable().optional(),
+  /**
+   * The kind of business (a preset id the published version defines). Its Modules are built
+   * and `enabledModules` adds extras on top; for the general kind `enabledModules` is the pick.
+   */
+  businessKind: import_zod8.z.string().regex(/^[a-z][a-z0-9-]{0,39}$/).optional()
 });
-var creationSourceSchema = import_zod7.z.discriminatedUnion("type", [
+var creationSourceSchema = import_zod8.z.discriminatedUnion("type", [
   creationSourceBlankSchema,
   creationSourceBlueprintSchema
 ]);
-var moduleInstallHandoffSchema = import_zod7.z.object({
-  moduleName: import_zod7.z.string().min(1),
-  homeProjectId: import_zod7.z.string().uuid(),
-  installedVersion: import_zod7.z.string().min(1),
-  baselineSha: import_zod7.z.string().min(1),
-  mounts: import_zod7.z.array(
-    import_zod7.z.object({
-      group: import_zod7.z.string(),
-      segment: import_zod7.z.string()
+var moduleInstallHandoffSchema = import_zod8.z.object({
+  moduleName: import_zod8.z.string().min(1),
+  homeProjectId: import_zod8.z.string().uuid(),
+  installedVersion: import_zod8.z.string().min(1),
+  baselineSha: import_zod8.z.string().min(1),
+  mounts: import_zod8.z.array(
+    import_zod8.z.object({
+      group: import_zod8.z.string(),
+      segment: import_zod8.z.string()
     })
   ),
-  integration: import_zod7.z.array(import_zod7.z.string()),
-  workflows: import_zod7.z.array(import_zod7.z.string()),
-  prunedEnhancements: import_zod7.z.array(import_zod7.z.string()),
-  restoredEnhancements: import_zod7.z.array(import_zod7.z.string()).optional(),
-  permissions: import_zod7.z.array(
-    import_zod7.z.object({
-      key: import_zod7.z.string().min(1),
-      description: import_zod7.z.string().min(1)
+  integration: import_zod8.z.array(import_zod8.z.string()),
+  workflows: import_zod8.z.array(import_zod8.z.string()),
+  prunedEnhancements: import_zod8.z.array(import_zod8.z.string()),
+  restoredEnhancements: import_zod8.z.array(import_zod8.z.string()).optional(),
+  permissions: import_zod8.z.array(
+    import_zod8.z.object({
+      key: import_zod8.z.string().min(1),
+      description: import_zod8.z.string().min(1)
     })
   ).optional()
 });
 
 // ../../packages/lib/src/shared/schema-ops.ts
-var import_zod8 = require("zod");
-var columnSpecSchema = import_zod8.z.object({
-  name: import_zod8.z.string().min(1).max(63),
-  pgType: import_zod8.z.string().min(1),
-  nullable: import_zod8.z.boolean(),
+var import_zod9 = require("zod");
+var columnSpecSchema = import_zod9.z.object({
+  name: import_zod9.z.string().min(1).max(63),
+  pgType: import_zod9.z.string().min(1),
+  nullable: import_zod9.z.boolean(),
   /**
    * A SQL expression used as the column default, as a raw string (e.g. `'t'`,
    * `0`, `now()`, `gen_random_uuid()`). `null` or omitted means no default.
    * NOT a JS literal — must already be a valid SQL expression.
    */
-  default: import_zod8.z.string().nullable().optional(),
-  fieldType: import_zod8.z.string().optional(),
-  fieldConfig: import_zod8.z.record(import_zod8.z.string(), import_zod8.z.unknown()).optional()
+  default: import_zod9.z.string().nullable().optional(),
+  fieldType: import_zod9.z.string().optional(),
+  fieldConfig: import_zod9.z.record(import_zod9.z.string(), import_zod9.z.unknown()).optional()
 });
-var referentialActionSchema = import_zod8.z.enum([
+var referentialActionSchema = import_zod9.z.enum([
   "cascade",
   "set null",
   "set default",
   "restrict",
   "no action"
 ]);
-var schemaOpSchema = import_zod8.z.discriminatedUnion("type", [
+var schemaOpSchema = import_zod9.z.discriminatedUnion("type", [
   // Tables
-  import_zod8.z.object({
-    type: import_zod8.z.literal("createTable"),
-    table: import_zod8.z.string().min(1).max(63),
-    columns: import_zod8.z.array(columnSpecSchema).min(1),
-    primaryKey: import_zod8.z.array(import_zod8.z.string()).optional(),
-    ifNotExists: import_zod8.z.boolean().optional()
+  import_zod9.z.object({
+    type: import_zod9.z.literal("createTable"),
+    table: import_zod9.z.string().min(1).max(63),
+    columns: import_zod9.z.array(columnSpecSchema).min(1),
+    primaryKey: import_zod9.z.array(import_zod9.z.string()).optional(),
+    ifNotExists: import_zod9.z.boolean().optional()
   }),
-  import_zod8.z.object({
-    type: import_zod8.z.literal("dropTable"),
-    table: import_zod8.z.string().min(1).max(63),
-    cascade: import_zod8.z.boolean().optional(),
-    ifExists: import_zod8.z.boolean().optional()
+  import_zod9.z.object({
+    type: import_zod9.z.literal("dropTable"),
+    table: import_zod9.z.string().min(1).max(63),
+    cascade: import_zod9.z.boolean().optional(),
+    ifExists: import_zod9.z.boolean().optional()
   }),
-  import_zod8.z.object({
-    type: import_zod8.z.literal("renameTable"),
-    from: import_zod8.z.string().min(1).max(63),
-    to: import_zod8.z.string().min(1).max(63)
+  import_zod9.z.object({
+    type: import_zod9.z.literal("renameTable"),
+    from: import_zod9.z.string().min(1).max(63),
+    to: import_zod9.z.string().min(1).max(63)
   }),
   // Columns
-  import_zod8.z.object({
-    type: import_zod8.z.literal("addColumn"),
-    table: import_zod8.z.string().min(1).max(63),
+  import_zod9.z.object({
+    type: import_zod9.z.literal("addColumn"),
+    table: import_zod9.z.string().min(1).max(63),
     column: columnSpecSchema,
-    ifNotExists: import_zod8.z.boolean().optional()
+    ifNotExists: import_zod9.z.boolean().optional()
   }),
-  import_zod8.z.object({
-    type: import_zod8.z.literal("dropColumn"),
-    table: import_zod8.z.string().min(1).max(63),
-    column: import_zod8.z.string().min(1).max(63),
-    cascade: import_zod8.z.boolean().optional(),
-    ifExists: import_zod8.z.boolean().optional()
+  import_zod9.z.object({
+    type: import_zod9.z.literal("dropColumn"),
+    table: import_zod9.z.string().min(1).max(63),
+    column: import_zod9.z.string().min(1).max(63),
+    cascade: import_zod9.z.boolean().optional(),
+    ifExists: import_zod9.z.boolean().optional()
   }),
-  import_zod8.z.object({
-    type: import_zod8.z.literal("renameColumn"),
-    table: import_zod8.z.string().min(1).max(63),
-    from: import_zod8.z.string().min(1).max(63),
-    to: import_zod8.z.string().min(1).max(63)
+  import_zod9.z.object({
+    type: import_zod9.z.literal("renameColumn"),
+    table: import_zod9.z.string().min(1).max(63),
+    from: import_zod9.z.string().min(1).max(63),
+    to: import_zod9.z.string().min(1).max(63)
   }),
-  import_zod8.z.object({
-    type: import_zod8.z.literal("alterColumnType"),
-    table: import_zod8.z.string().min(1).max(63),
-    column: import_zod8.z.string().min(1).max(63),
-    newType: import_zod8.z.string().min(1),
+  import_zod9.z.object({
+    type: import_zod9.z.literal("alterColumnType"),
+    table: import_zod9.z.string().min(1).max(63),
+    column: import_zod9.z.string().min(1).max(63),
+    newType: import_zod9.z.string().min(1),
     /** Optional USING expression for potentially-lossy casts */
-    using: import_zod8.z.string().optional()
+    using: import_zod9.z.string().optional()
   }),
-  import_zod8.z.object({
-    type: import_zod8.z.literal("alterColumnNullable"),
-    table: import_zod8.z.string().min(1).max(63),
-    column: import_zod8.z.string().min(1).max(63),
-    nullable: import_zod8.z.boolean()
+  import_zod9.z.object({
+    type: import_zod9.z.literal("alterColumnNullable"),
+    table: import_zod9.z.string().min(1).max(63),
+    column: import_zod9.z.string().min(1).max(63),
+    nullable: import_zod9.z.boolean()
   }),
-  import_zod8.z.object({
-    type: import_zod8.z.literal("alterColumnDefault"),
-    table: import_zod8.z.string().min(1).max(63),
-    column: import_zod8.z.string().min(1).max(63),
+  import_zod9.z.object({
+    type: import_zod9.z.literal("alterColumnDefault"),
+    table: import_zod9.z.string().min(1).max(63),
+    column: import_zod9.z.string().min(1).max(63),
     /** null means drop the default; otherwise a SQL expression string. */
-    default: import_zod8.z.string().nullable()
+    default: import_zod9.z.string().nullable()
   }),
   // Indexes
-  import_zod8.z.object({
-    type: import_zod8.z.literal("addIndex"),
-    table: import_zod8.z.string().min(1).max(63),
-    name: import_zod8.z.string().min(1).max(63),
-    columns: import_zod8.z.array(import_zod8.z.string().min(1)).min(1),
-    unique: import_zod8.z.boolean().optional(),
+  import_zod9.z.object({
+    type: import_zod9.z.literal("addIndex"),
+    table: import_zod9.z.string().min(1).max(63),
+    name: import_zod9.z.string().min(1).max(63),
+    columns: import_zod9.z.array(import_zod9.z.string().min(1)).min(1),
+    unique: import_zod9.z.boolean().optional(),
     /** Partial-index WHERE clause, as a raw SQL expression */
-    where: import_zod8.z.string().optional(),
-    ifNotExists: import_zod8.z.boolean().optional()
+    where: import_zod9.z.string().optional(),
+    ifNotExists: import_zod9.z.boolean().optional()
   }),
-  import_zod8.z.object({
-    type: import_zod8.z.literal("dropIndex"),
-    name: import_zod8.z.string().min(1).max(63),
-    cascade: import_zod8.z.boolean().optional(),
-    ifExists: import_zod8.z.boolean().optional()
+  import_zod9.z.object({
+    type: import_zod9.z.literal("dropIndex"),
+    name: import_zod9.z.string().min(1).max(63),
+    cascade: import_zod9.z.boolean().optional(),
+    ifExists: import_zod9.z.boolean().optional()
   }),
   // Constraints
-  import_zod8.z.object({
-    type: import_zod8.z.literal("addForeignKey"),
-    table: import_zod8.z.string().min(1).max(63),
-    name: import_zod8.z.string().min(1).max(63),
-    columns: import_zod8.z.array(import_zod8.z.string().min(1)).min(1),
-    refTable: import_zod8.z.string().min(1).max(63),
-    refColumns: import_zod8.z.array(import_zod8.z.string().min(1)).min(1),
+  import_zod9.z.object({
+    type: import_zod9.z.literal("addForeignKey"),
+    table: import_zod9.z.string().min(1).max(63),
+    name: import_zod9.z.string().min(1).max(63),
+    columns: import_zod9.z.array(import_zod9.z.string().min(1)).min(1),
+    refTable: import_zod9.z.string().min(1).max(63),
+    refColumns: import_zod9.z.array(import_zod9.z.string().min(1)).min(1),
     onDelete: referentialActionSchema.optional(),
     onUpdate: referentialActionSchema.optional()
   }),
-  import_zod8.z.object({
-    type: import_zod8.z.literal("addUniqueConstraint"),
-    table: import_zod8.z.string().min(1).max(63),
-    name: import_zod8.z.string().min(1).max(63),
-    columns: import_zod8.z.array(import_zod8.z.string().min(1)).min(1)
+  import_zod9.z.object({
+    type: import_zod9.z.literal("addUniqueConstraint"),
+    table: import_zod9.z.string().min(1).max(63),
+    name: import_zod9.z.string().min(1).max(63),
+    columns: import_zod9.z.array(import_zod9.z.string().min(1)).min(1)
   }),
-  import_zod8.z.object({
-    type: import_zod8.z.literal("addCheckConstraint"),
-    table: import_zod8.z.string().min(1).max(63),
-    name: import_zod8.z.string().min(1).max(63),
-    expression: import_zod8.z.string().min(1)
+  import_zod9.z.object({
+    type: import_zod9.z.literal("addCheckConstraint"),
+    table: import_zod9.z.string().min(1).max(63),
+    name: import_zod9.z.string().min(1).max(63),
+    expression: import_zod9.z.string().min(1)
   }),
-  import_zod8.z.object({
-    type: import_zod8.z.literal("dropConstraint"),
-    table: import_zod8.z.string().min(1).max(63),
-    name: import_zod8.z.string().min(1).max(63),
-    cascade: import_zod8.z.boolean().optional(),
-    ifExists: import_zod8.z.boolean().optional()
+  import_zod9.z.object({
+    type: import_zod9.z.literal("dropConstraint"),
+    table: import_zod9.z.string().min(1).max(63),
+    name: import_zod9.z.string().min(1).max(63),
+    cascade: import_zod9.z.boolean().optional(),
+    ifExists: import_zod9.z.boolean().optional()
   }),
   // Enum types
-  import_zod8.z.object({
-    type: import_zod8.z.literal("createEnum"),
-    name: import_zod8.z.string().min(1).max(63),
-    values: import_zod8.z.array(import_zod8.z.string().min(1)).min(1)
+  import_zod9.z.object({
+    type: import_zod9.z.literal("createEnum"),
+    name: import_zod9.z.string().min(1).max(63),
+    values: import_zod9.z.array(import_zod9.z.string().min(1)).min(1)
   }),
-  import_zod8.z.object({
-    type: import_zod8.z.literal("alterEnumAddValue"),
-    name: import_zod8.z.string().min(1).max(63),
-    value: import_zod8.z.string().min(1),
+  import_zod9.z.object({
+    type: import_zod9.z.literal("alterEnumAddValue"),
+    name: import_zod9.z.string().min(1).max(63),
+    value: import_zod9.z.string().min(1),
     /** Position the new value before an existing one (mutually exclusive with `after`) */
-    before: import_zod8.z.string().optional(),
+    before: import_zod9.z.string().optional(),
     /** Position the new value after an existing one (mutually exclusive with `before`) */
-    after: import_zod8.z.string().optional(),
-    ifNotExists: import_zod8.z.boolean().optional()
+    after: import_zod9.z.string().optional(),
+    ifNotExists: import_zod9.z.boolean().optional()
   }),
-  import_zod8.z.object({
-    type: import_zod8.z.literal("dropEnum"),
-    name: import_zod8.z.string().min(1).max(63),
-    cascade: import_zod8.z.boolean().optional(),
-    ifExists: import_zod8.z.boolean().optional()
+  import_zod9.z.object({
+    type: import_zod9.z.literal("dropEnum"),
+    name: import_zod9.z.string().min(1).max(63),
+    cascade: import_zod9.z.boolean().optional(),
+    ifExists: import_zod9.z.boolean().optional()
   }),
   // Extensions
-  import_zod8.z.object({
-    type: import_zod8.z.literal("createExtension"),
-    name: import_zod8.z.string().min(1),
-    ifNotExists: import_zod8.z.boolean().optional()
+  import_zod9.z.object({
+    type: import_zod9.z.literal("createExtension"),
+    name: import_zod9.z.string().min(1),
+    ifNotExists: import_zod9.z.boolean().optional()
   }),
   // Data operations
   /**
@@ -6198,26 +6221,26 @@ var schemaOpSchema = import_zod8.z.discriminatedUnion("type", [
    * destructive — requires explicit confirm to replay on prod. The
    * `description` is what the agent/user sees at confirm time.
    */
-  import_zod8.z.object({
-    type: import_zod8.z.literal("backfill"),
-    description: import_zod8.z.string().min(1),
-    sql: import_zod8.z.string().min(1)
+  import_zod9.z.object({
+    type: import_zod9.z.literal("backfill"),
+    description: import_zod9.z.string().min(1),
+    sql: import_zod9.z.string().min(1)
   }),
   /**
    * Escape hatch for DDL the structured ops can't express. `destructive`
    * forces classification — use false only for genuinely additive-only SQL
    * (e.g. CREATE EXTENSION variants the structured op doesn't cover).
    */
-  import_zod8.z.object({
-    type: import_zod8.z.literal("rawSql"),
-    description: import_zod8.z.string().min(1),
-    sql: import_zod8.z.string().min(1),
-    destructive: import_zod8.z.boolean()
+  import_zod9.z.object({
+    type: import_zod9.z.literal("rawSql"),
+    description: import_zod9.z.string().min(1),
+    sql: import_zod9.z.string().min(1),
+    destructive: import_zod9.z.boolean()
   })
 ]);
 
 // ../../packages/lib/src/server/module-rail/ops.ts
-var import_zod9 = require("zod");
+var import_zod10 = require("zod");
 
 // ../../packages/lib/src/server/module-rail/reconcile.ts
 var SANDBOX_BATCH_SIZE = 200;