@stardeck-customer-apps/compose 0.14.0 → 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);
@@ -2097,6 +2097,7 @@ var JSON_SECRET_PAIR = new RegExp(
   "g"
 );
 var SECRET_QUOTE_OPENER = new RegExp(String.raw`\b${SECRET_NAME}\s*=\s*(['"])`, "g");
+var SHELL_QUOTE_CONTINUATION = String.raw`\''`;
 function redactSecrets(text) {
   return text.replace(/x-access-token:[^@\s]+@/g, "x-access-token:***@").replace(/https:\/\/(?!x-access-token:)[^/\s:@]+:[^/\s@]+@/gi, "https://***:***@").replace(/\b(gh[pousr]_)[A-Za-z0-9]+/g, "$1***").replace(/\b(github_pat_)[A-Za-z0-9_]+/g, "$1***").replace(/\b(postgres(?:ql)?:\/\/)([^:\s/@]+):([^@\s/]+)@/gi, "$1$2:***@").replace(/\b(npm_[A-Za-z0-9]+)/g, "npm_***").replace(/(_authToken=)([^\s&]+)/gi, "$1***").replace(SECRET_ASSIGNMENT, "$1=***").replace(JSON_SECRET_PAIR, '"$1"$2"***"').replace(/\b(Authorization:\s*(?:Bearer|Basic)\s+)\S+/gi, "$1***");
 }
@@ -2388,10 +2389,12 @@ var modulePermissionClaimSchema = import_zod2.z.object({
   /** Human label for the deployment auth config row. */
   description: descriptionSchema,
   /**
-   * The default organization roles that hold this key when the platform
-   * first registers it on an app (a Blueprint fork, a Module install). Admin
-   * holds every key without being listed; External Viewer never holds one.
-   * Changing a role's grants afterwards is the organization's business.
+   * The standard organization roles that hold this key. The platform sets them on every app
+   * (a Blueprint fork, a Module install or uninstall, every Blueprint update), so this list is
+   * the truth: a role added here gains the key, a role removed loses it, and nobody can edit a
+   * standard role's grants on a Module key. Admin holds every key without being listed;
+   * External Viewer never holds one. An organization that wants different access duplicates the
+   * standard role and edits the copy.
    */
   roles: import_zod2.z.array(import_zod2.z.enum(MODULE_PERMISSION_DEFAULT_ROLES)).optional()
 }).strict();
@@ -4033,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`;
@@ -4837,6 +4858,9 @@ function enhancementImport(owner, peer) {
 function scopeLabel(scope) {
   return scope.kind === "root" ? "root" : `enhancement:${scope.peer}`;
 }
+function endpointMarkerOwnsStub(marker, stub) {
+  return stub != null && marker?.kind === "endpoint" && marker.owner === stub.owner;
+}
 function formatEndpointMarker(owner, scope) {
   return `// ${MODULE_STUB_MARKER} owner=${owner} scope=${scopeLabel(scope)}`;
 }
@@ -5538,7 +5562,7 @@ function planCompositionArtifacts(input) {
     const legacy = parseLegacyApiAdapter(pagePath, content);
     const plannedRoute = plannedRouteByPath.get(pagePath);
     const plannedEndpoint = plannedEndpointByPath.get(pagePath);
-    const isExactPlannedMatch = plannedRoute != null && marker != null && marker.kind === "route" && marker.owner === plannedRoute.owner && marker.nextRelativePath === plannedRoute.nextRelativePath || plannedEndpoint != null && (marker != null && marker.kind === "endpoint" && marker.owner === plannedEndpoint.owner && scopeLabel(marker.scope) === scopeLabel(plannedEndpoint.scope) || legacy != null) || plannedRoute != null && legacyRouteAdapterMatchesStub(pagePath, content, plannedRoute);
+    const isExactPlannedMatch = plannedRoute != null && marker != null && marker.kind === "route" && marker.owner === plannedRoute.owner && marker.nextRelativePath === plannedRoute.nextRelativePath || plannedEndpoint != null && (endpointMarkerOwnsStub(marker, plannedEndpoint) || legacy != null) || plannedRoute != null && legacyRouteAdapterMatchesStub(pagePath, content, plannedRoute);
     if (isExactPlannedMatch) {
       continue;
     }
@@ -5681,9 +5705,7 @@ function planCompositionArtifacts(input) {
     }
     if (marker.kind === "endpoint") {
       const stub = endpointStubByPath.get(path4);
-      const ownerMatches = stub != null && marker.owner === stub.owner;
-      const scopeMatches = stub != null && scopeLabel(marker.scope) === scopeLabel(stub.scope);
-      if (!ownerMatches || !scopeMatches) {
+      if (!endpointMarkerOwnsStub(marker, stub)) {
         return {
           ok: false,
           error: `[ModuleRail] composition artifacts: refusing to overwrite incongruent marker ownership at ${path4} (existing owner=${marker.owner} scope=${scopeLabel(marker.scope)} vs planned owner=${stub?.owner ?? "?"} scope=${stub ? scopeLabel(stub.scope) : "?"})`,
@@ -5986,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
@@ -6001,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
   /**
@@ -6194,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;
@@ -6326,39 +6353,24 @@ async function assertNoRootRoutesWhenMountsEmpty(context, moduleName) {
     );
   }
 }
-async function assertNoEnhancementRoutes(context, moduleName) {
-  const enhancementsDir = `${MODULES_SANDBOX_DIR}/${moduleName}/enhancements`;
-  const enhancementEntries = await listImmediateEntries(context.sandbox, enhancementsDir, {
-    optional: true,
-    label: `enhancements for ${moduleName}`
-  });
-  for (const entry of enhancementEntries) {
-    if (entry.kind !== "dir") continue;
-    const sliceRoutes = `${enhancementsDir}/${entry.name}/routes`;
-    const sliceProbe = await context.sandbox.exec(
-      [
-        `p=${shellQuote(sliceRoutes)}`,
-        `if test -L "$p" || test -e "$p"; then exit 2; else exit 0; fi`
-      ].join("\n"),
-      { raiseOnError: false }
-    );
-    if (sliceProbe.exitCode === 2) {
+async function assertNoEnhancementRoutePaths(context, paths) {
+  const kinds = await classifySandboxPathPresenceKindMany(context, paths, "enhancement-route-kind");
+  for (const sliceRoutes of paths) {
+    const kind = kinds.get(sliceRoutes);
+    if (kind === "absent") continue;
+    if (kind !== "unreadable" && kind !== void 0) {
       throw new Error(
         `[ModuleRail] composition artifacts: enhancement slice routes/ are forbidden at ${sliceRoutes}`
       );
     }
-    if (sliceProbe.exitCode !== 0) {
-      const detail = typeof sliceProbe.error === "string" && sliceProbe.error.trim() || sliceProbe.output.trim() || `exit ${sliceProbe.exitCode}`;
-      throw new Error(
-        `[ModuleRail] composition artifacts: cannot probe ${sliceRoutes}: ${redactSecrets(detail)}`
-      );
-    }
+    throw new Error(
+      `[ModuleRail] composition artifacts: cannot probe ${sliceRoutes}: entry-kind:${kind ?? "missing"}`
+    );
   }
 }
-async function discoverModuleRouteEntries(context, moduleName) {
+async function discoverRootRouteEntries(context, moduleName) {
   const modulePath = `${MODULES_SANDBOX_DIR}/${moduleName}`;
   const routesDir = `${modulePath}/routes`;
-  await assertNoEnhancementRoutes(context, moduleName);
   const quotedRoutes = shellQuote(routesDir);
   const listResult = await context.sandbox.exec(
     [
@@ -6812,7 +6824,8 @@ async function classifySandboxPathPresenceKindMany(context, paths, probeToken) {
         `# Leaf is missing. A missing intermediate parent means the path is simply`,
         `# absent (new nested writes). Only an existing-but-inaccessible parent`,
         `# is unreadable \u2014 never conflate ENOENT parents with EACCES.`,
-        `parent=$(dirname -- "$p")`,
+        // Probe paths are nested repo-relative paths; do not spawn dirname per missing file.
+        `parent=\${p%/*}`,
         `if test ! -e "$parent" && test ! -L "$parent"; then`,
         `  printf 'entry-kind:absent\\t%s\\n' "$p"`,
         `elif ls -ld -- "$parent" >/dev/null 2>&1; then`,
@@ -7357,14 +7370,21 @@ async function reconcileCompositionArtifacts(context, options = {}) {
     manifestsByName
   );
   const routeEntriesByOwner = {};
+  await assertNoEnhancementRoutePaths(
+    context,
+    moduleRuntimeFacts.flatMap(
+      ({ moduleName, onDiskEnhancementDirs }) => onDiskEnhancementDirs.map(
+        (peer) => `${MODULES_SANDBOX_DIR}/${moduleName}/enhancements/${peer}/routes`
+      )
+    )
+  );
   for (const moduleName of composedNames) {
     const manifest = manifestsByName[moduleName];
-    await assertNoEnhancementRoutes(context, moduleName);
     if (manifest.mounts.length === 0) {
       await assertNoRootRoutesWhenMountsEmpty(context, moduleName);
       routeEntriesByOwner[moduleName] = [];
     } else {
-      routeEntriesByOwner[moduleName] = await discoverModuleRouteEntries(context, moduleName);
+      routeEntriesByOwner[moduleName] = await discoverRootRouteEntries(context, moduleName);
     }
   }
   const existingGeneratedPaths = await listExistingGeneratedStubPaths(context);