@supacloud/cli 0.73.0 → 0.74.0

package/dist/index.js

@@ -221509,6 +221509,13 @@ var init_validate = __esm2(() => {
     "effect-dependencies-required": { code: "SC3038", docsUrl: "https://supacloud.dev/errors/SC3038" },
     "effect-command-retry-forbidden": { code: "SC3039", docsUrl: "https://supacloud.dev/errors/SC3039" },
     "effect-dependency-type": { code: "SC3040", docsUrl: "https://supacloud.dev/errors/SC3040" },
+    "effect-error-type": { code: "SC3041", docsUrl: "https://supacloud.dev/errors/SC3041" },
+    "effect-error-mapping-type": { code: "SC3042", docsUrl: "https://supacloud.dev/errors/SC3042" },
+    "effect-dependency-mismatch": { code: "SC3043", docsUrl: "https://supacloud.dev/errors/SC3043" },
+    "effect-timeout-required": { code: "SC3044", docsUrl: "https://supacloud.dev/errors/SC3044" },
+    "effect-direct-runtime-execution": { code: "SC3045", docsUrl: "https://supacloud.dev/errors/SC3045" },
+    "effect-direct-throw": { code: "SC3046", docsUrl: "https://supacloud.dev/errors/SC3046" },
+    "effect-promise-return": { code: "SC3047", docsUrl: "https://supacloud.dev/errors/SC3047" },
     "invalid-route-response-map": { code: "SC3024", docsUrl: "https://supacloud.dev/errors/SC3024" },
     "invalid-route-response-selector": { code: "SC3025", docsUrl: "https://supacloud.dev/errors/SC3025" },
     "conflicting-route-response-schema": { code: "SC3026", docsUrl: "https://supacloud.dev/errors/SC3026" },
@@ -244750,6 +244757,13 @@ function withDiagnosticMetadata(diagnostic) {
   const metadata = COMPILER_DIAGNOSTIC_CODES[diagnostic.code];
   return metadata ? { ...diagnostic, errorCode: metadata.code, docsUrl: metadata.docsUrl } : diagnostic;
 }
+var DEFAULT_EFFECT_ANALYSIS_OPTIONS = {
+  requireTaggedErrorTypes: true,
+  requireExactDependencyTypes: true,
+  requireTimeoutForDependencies: true,
+  forbidDirectRuntimeExecution: true,
+  forbidDirectThrows: true
+};
 function nodeText(node) {
   return node.getText(node.getSourceFile());
 }
@@ -244795,7 +244809,7 @@ function descendantsOfKind(root, predicate) {
   visit(root);
   return result;
 }
-async function analyzeProject(rootDir, include, cache, changedPaths) {
+async function analyzeProject(rootDir, include, cache, changedPaths, effectOptions = {}) {
   const session = cache?.programSession ?? createIncrementalProgramSession(rootDir);
   if (cache)
     cache.programSession = session;
@@ -244814,8 +244828,21 @@ async function analyzeProject(rootDir, include, cache, changedPaths) {
     moduleHandlerFiles: new Map,
     infraResources: new Map,
     infraResourceClasses: new Map,
-    diagnostics: []
+    diagnostics: [],
+    effectOptions: {
+      ...DEFAULT_EFFECT_ANALYSIS_OPTIONS,
+      requireTaggedErrorTypes: effectOptions.requireTaggedErrorTypes ?? DEFAULT_EFFECT_ANALYSIS_OPTIONS.requireTaggedErrorTypes,
+      requireExactDependencyTypes: effectOptions.requireExactDependencyTypes ?? DEFAULT_EFFECT_ANALYSIS_OPTIONS.requireExactDependencyTypes,
+      requireTimeoutForDependencies: effectOptions.requireTimeoutForDependencies ?? DEFAULT_EFFECT_ANALYSIS_OPTIONS.requireTimeoutForDependencies,
+      forbidDirectRuntimeExecution: effectOptions.forbidDirectRuntimeExecution ?? DEFAULT_EFFECT_ANALYSIS_OPTIONS.forbidDirectRuntimeExecution,
+      forbidDirectThrows: effectOptions.forbidDirectThrows ?? DEFAULT_EFFECT_ANALYSIS_OPTIONS.forbidDirectThrows
+    }
   };
+  if (ctx.effectOptions.forbidDirectRuntimeExecution) {
+    for (const sourceFile of sourceFiles) {
+      scanEffectRuntimeEscapes(sourceFile, ctx);
+    }
+  }
   const nativeTraitFiles = new Map;
   for (const diagnostic of session.getDiagnostics()) {
     ctx.diagnostics.push(toCompilerDiagnostic(diagnostic, rootDir));
@@ -245991,11 +246018,150 @@ function declaredClassType(declaration, ctx) {
   return symbol ? ctx.checker.getDeclaredTypeOfSymbol(symbol) : undefined;
 }
 function typeArgumentsOf(type, ctx) {
-  return isTypeReference(type) ? ctx.checker.getTypeArguments(type) : [];
+  if (!isTypeReference(type))
+    return [];
+  const argumentsFromChecker = ctx.checker.getTypeArguments(type);
+  if (argumentsFromChecker.length > 0)
+    return argumentsFromChecker;
+  const reference = type;
+  if (reference.resolvedTypeArguments && reference.resolvedTypeArguments.length > 0) {
+    return reference.resolvedTypeArguments;
+  }
+  return reference.aliasTypeArguments ?? [];
 }
 function isTypeReference(type) {
   return "target" in type;
 }
+function effectTypeArgumentsOf(type, ctx) {
+  if (!type)
+    return;
+  const reference = isTypeReference(type) ? type : undefined;
+  const target = reference?.target ?? type;
+  const symbol = target.aliasSymbol ?? target.getSymbol();
+  const text = ctx.checker.typeToString(type, undefined, ts7.TypeFormatFlags.NoTruncation);
+  if (symbol?.getName() !== "Effect" && !/^(?:Effect\.)?Effect</.test(text))
+    return;
+  const args = typeArgumentsOf(type, ctx);
+  return args.length >= 3 ? [args[0], args[1], args[2]] : undefined;
+}
+function effectTypeName(type, location, ctx) {
+  return ctx.checker.typeToString(type, location, ts7.TypeFormatFlags.NoTruncation);
+}
+function stringLiteralTypeValue(type) {
+  return (type.flags & ts7.TypeFlags.StringLiteral) !== 0 ? type.value : undefined;
+}
+function effectFailureTags(type, location, ctx) {
+  if ((type.flags & ts7.TypeFlags.Never) !== 0)
+    return { tags: [], invalid: false };
+  if ((type.flags & (ts7.TypeFlags.Any | ts7.TypeFlags.Unknown)) !== 0) {
+    return { tags: [], invalid: true };
+  }
+  if (type.isUnion()) {
+    return type.types.reduce((result, part) => {
+      const next = effectFailureTags(part, location, ctx);
+      result.tags.push(...next.tags);
+      result.invalid ||= next.invalid;
+      return result;
+    }, { tags: [], invalid: false });
+  }
+  const apparent = ctx.checker.getApparentType(type);
+  for (const propertyName of ["_tag", "tag"]) {
+    const property = ctx.checker.getPropertyOfType(apparent, propertyName);
+    if (!property)
+      continue;
+    const propertyType = ctx.checker.getTypeOfSymbolAtLocation(property, location);
+    const tag = stringLiteralTypeValue(propertyType);
+    if (tag)
+      return { tags: [tag], invalid: false };
+  }
+  return { tags: [], invalid: true };
+}
+function effectEnvironmentNames(type, location, ctx) {
+  if ((type.flags & ts7.TypeFlags.Never) !== 0)
+    return { names: [], invalid: false };
+  if ((type.flags & (ts7.TypeFlags.Any | ts7.TypeFlags.Unknown)) !== 0) {
+    return { names: [], invalid: true };
+  }
+  if (type.isUnion() || type.isIntersection()) {
+    return type.types.reduce((result, part) => {
+      const next = effectEnvironmentNames(part, location, ctx);
+      result.names.push(...next.names);
+      result.invalid ||= next.invalid;
+      return result;
+    }, { names: [], invalid: false });
+  }
+  const literal = stringLiteralTypeValue(type);
+  if (literal)
+    return { names: [literal], invalid: false };
+  const symbolName = type.getSymbol()?.getName();
+  if (symbolName && symbolName !== "__type" && symbolName !== "__object") {
+    return { names: [symbolName], invalid: false };
+  }
+  const text = effectTypeName(type, location, ctx).trim();
+  if (text && text !== "object")
+    return { names: [text], invalid: false };
+  return { names: [], invalid: true };
+}
+function sortedUnique(values) {
+  return [...new Set(values)].sort((left, right) => left.localeCompare(right, "en"));
+}
+function pushEffectDiagnostic(ctx, code, file, line, message, suggestion) {
+  const metadata = COMPILER_DIAGNOSTIC_CODES[code];
+  ctx.diagnostics.push({
+    severity: "error",
+    code,
+    ...metadata ? { errorCode: metadata.code, docsUrl: metadata.docsUrl } : {},
+    file,
+    line,
+    message,
+    suggestion
+  });
+}
+function scanEffectRuntimeEscapes(sourceFile, ctx) {
+  const relativeFile = sourcePath(ctx.rootDir, sourceFile.fileName);
+  if (/\.(?:test|spec)\.[cm]?[jt]sx?$/.test(relativeFile))
+    return;
+  const namespaceBindings = new Set;
+  const runtimeBindings = new Set;
+  for (const statement of sourceFile.statements) {
+    if (!ts7.isImportDeclaration(statement) || !ts7.isStringLiteral(statement.moduleSpecifier))
+      continue;
+    const moduleName = statement.moduleSpecifier.text;
+    if (moduleName !== "effect" && moduleName !== "effect/Effect" && moduleName !== "effect/Runtime")
+      continue;
+    const clause = statement.importClause;
+    if (!clause)
+      continue;
+    if (clause.name)
+      namespaceBindings.add(clause.name.text);
+    if (clause.namedBindings && ts7.isNamespaceImport(clause.namedBindings)) {
+      namespaceBindings.add(clause.namedBindings.name.text);
+    } else if (clause.namedBindings && ts7.isNamedImports(clause.namedBindings)) {
+      for (const element of clause.namedBindings.elements) {
+        const imported = element.propertyName?.text ?? element.name.text;
+        if (moduleName === "effect" && (imported === "Effect" || imported === "Runtime")) {
+          namespaceBindings.add(element.name.text);
+        }
+        if (["runPromise", "runPromiseExit", "runSync", "runFork"].includes(imported)) {
+          runtimeBindings.add(element.name.text);
+        }
+      }
+    }
+  }
+  if (namespaceBindings.size === 0 && runtimeBindings.size === 0)
+    return;
+  for (const call of descendantsOfKind(sourceFile, ts7.isCallExpression)) {
+    let runtimeName;
+    if (ts7.isPropertyAccessExpression(call.expression) && namespaceBindings.has(call.expression.expression.getText(sourceFile)) && ["runPromise", "runPromiseExit", "runSync", "runFork"].includes(call.expression.name.text)) {
+      runtimeName = call.expression.name.text;
+    } else if (ts7.isIdentifier(call.expression) && runtimeBindings.has(call.expression.text)) {
+      runtimeName = call.expression.text;
+    }
+    if (!runtimeName)
+      continue;
+    pushEffectDiagnostic(ctx, "effect-direct-runtime-execution", sourcePath(ctx.rootDir, sourceFile.fileName), lineOf2(call), `Direct ${runtimeName} execution escapes the Effect boundary.`, "Return the Effect program to the Elysia boundary; only the framework adapter may interpret it.");
+  }
+}
 function isUnknownOrAny(type) {
   return (type.flags & (ts7.TypeFlags.Any | ts7.TypeFlags.Unknown)) !== 0;
 }
@@ -246059,7 +246225,8 @@ function parseController(input, ctx) {
         handler: propertyName(method.name)
       };
       const signature = ctx.checker.getSignatureFromDeclaration(method);
-      const resultType = signature && ctx.checker.typeToString(signature.getReturnType());
+      const returnType = signature?.getReturnType();
+      const resultType = returnType && ctx.checker.typeToString(returnType);
       if (resultType && /\bResponse\b/.test(resultType))
         route.nativeResponse = true;
       const pathParams = [];
@@ -246390,6 +246557,18 @@ function parseController(input, ctx) {
                 });
               } else {
                 effect.dependencies = dependenciesExpr.elements.map((element) => element.text);
+                if (new Set(effect.dependencies).size !== effect.dependencies.length) {
+                  ctx.diagnostics.push({
+                    severity: "error",
+                    code: "invalid-effect-dependencies",
+                    errorCode: "SC3033",
+                    docsUrl: "https://supacloud.dev/errors/SC3033",
+                    file,
+                    line: lineOf2(dependenciesExpr),
+                    message: `Route ${route.handler} effect.dependencies must not contain duplicate service names.`,
+                    suggestion: "List each logical Effect dependency exactly once."
+                  });
+                }
               }
             }
             const errorsExpr = getProp(effectObject, "errors");
@@ -246438,10 +246617,26 @@ function parseController(input, ctx) {
                   errors.push({ tag, code, status, ...message === undefined ? {} : { message } });
                 }
                 effect.errors = errors;
+                if (new Set(errors.map((entry) => entry.tag)).size !== errors.length) {
+                  ctx.diagnostics.push({
+                    severity: "error",
+                    code: "invalid-effect-errors",
+                    errorCode: "SC3034",
+                    docsUrl: "https://supacloud.dev/errors/SC3034",
+                    file,
+                    line: lineOf2(errorsExpr),
+                    message: `Route ${route.handler} effect.errors must not contain duplicate tags.`,
+                    suggestion: "Map each tagged failure exactly once."
+                  });
+                }
               }
             }
             route.effect = effect;
-            if (!resultType || !/\bEffect(?:\.Effect)?(?:<|\s)/.test(resultType)) {
+            const effectArguments = effectTypeArgumentsOf(returnType, ctx);
+            const promiseReturn = Boolean(resultType && /\bPromise(?:<|\s)/.test(resultType));
+            if (promiseReturn) {
+              pushEffectDiagnostic(ctx, "effect-promise-return", file, lineOf2(method), `Route ${route.handler} returns Promise instead of an Effect program.`, "Return Effect.Effect<Success, Failure, Requirements>; the Elysia boundary owns Promise interpretation.");
+            } else if (!effectArguments) {
               ctx.diagnostics.push({
                 severity: "error",
                 code: "effect-return-type",
@@ -246453,18 +246648,37 @@ function parseController(input, ctx) {
                 suggestion: "Return Effect.Effect<Success, Failure, Requirements> from the handler."
               });
             }
-            for (const dependency of effect.dependencies ?? []) {
-              if (!resultType?.includes(dependency)) {
-                ctx.diagnostics.push({
-                  severity: "error",
-                  code: "effect-dependency-type",
-                  errorCode: "SC3040",
-                  docsUrl: "https://supacloud.dev/errors/SC3040",
-                  file,
-                  line: lineOf2(method),
-                  message: `Route ${route.handler} declares Effect dependency "${dependency}", but it is absent from the return type environment ${resultType ?? "unknown"}.`,
-                  suggestion: "Keep effect.dependencies aligned with the third Effect type parameter."
-                });
+            if (effectArguments) {
+              const [, failureType, environmentType] = effectArguments;
+              const failure = effectFailureTags(failureType, method, ctx);
+              if (ctx.effectOptions.requireTaggedErrorTypes && failure.invalid) {
+                pushEffectDiagnostic(ctx, "effect-error-type", file, lineOf2(method), `Route ${route.handler} must use never or a tagged failure union in Effect's error channel, not ${effectTypeName(failureType, method, ctx)}.`, "Replace unknown/any with never or a union of objects carrying a literal _tag.");
+              } else if (ctx.effectOptions.requireTaggedErrorTypes && effect.errors !== undefined && !failure.invalid) {
+                const declaredTags = sortedUnique(effect.errors.map((entry) => entry.tag));
+                const typedTags = sortedUnique(failure.tags);
+                if (declaredTags.join("\x00") !== typedTags.join("\x00")) {
+                  pushEffectDiagnostic(ctx, "effect-error-mapping-type", file, lineOf2(method), `Route ${route.handler} maps [${declaredTags.join(", ")}], but its Effect failure type declares [${typedTags.join(", ")}].`, "Make effect.errors and the Effect error type the same tagged union; do not hide unmapped failures.");
+                }
+              }
+              const environment = effectEnvironmentNames(environmentType, method, ctx);
+              if (ctx.effectOptions.requireExactDependencyTypes && effect.dependencies !== undefined) {
+                if (environment.invalid) {
+                  pushEffectDiagnostic(ctx, "effect-dependency-mismatch", file, lineOf2(method), `Route ${route.handler} uses an Effect environment that cannot be represented by its explicit dependency list.`, "Use named service types or never in the third Effect type parameter.");
+                } else {
+                  const declaredDependencies = sortedUnique(effect.dependencies);
+                  const typedDependencies = sortedUnique(environment.names);
+                  if (declaredDependencies.join("\x00") !== typedDependencies.join("\x00")) {
+                    pushEffectDiagnostic(ctx, "effect-dependency-mismatch", file, lineOf2(method), `Route ${route.handler} declares dependencies [${declaredDependencies.join(", ")}], but its Effect environment is [${typedDependencies.join(", ")}].`, "Make effect.dependencies exactly match the third Effect type parameter.");
+                  }
+                }
+              }
+              if (ctx.effectOptions.requireTimeoutForDependencies && (effect.dependencies?.length ?? 0) > 0 && effect.timeoutMs === undefined) {
+                pushEffectDiagnostic(ctx, "effect-timeout-required", file, lineOf2(method), `Route ${route.handler} declares external Effect dependencies without a timeout.`, "Add a positive effect.timeoutMs so external I/O cannot occupy a request indefinitely.");
+              }
+            }
+            if (ctx.effectOptions.forbidDirectThrows && method.body) {
+              for (const throwStatement of descendantsOfKind(method.body, ts7.isThrowStatement)) {
+                pushEffectDiagnostic(ctx, "effect-direct-throw", file, lineOf2(throwStatement), `Route ${route.handler} throws directly instead of representing failure in Effect.`, "Use Effect.fail with a tagged error value and map it in effect.errors.");
               }
             }
           }
@@ -247763,7 +247977,7 @@ async function renderOptionalGraphql(options) {
 }
 async function compileProject(options) {
   options = withDefaultGovernance(options);
-  const graph = await analyzeProject(options.rootDir, options.include, options.cache, options.changedPaths);
+  const graph = await analyzeProject(options.rootDir, options.include, options.cache, options.changedPaths, options.effect);
   const diagnostics = [
     ...graph.diagnostics ?? [],
     ...validateGraph(graph, options),
@@ -247828,7 +248042,7 @@ async function compileProject(options) {
 }
 async function checkProject(options) {
   options = withDefaultGovernance(options);
-  const graph = await analyzeProject(options.rootDir, options.include, options.cache, options.changedPaths);
+  const graph = await analyzeProject(options.rootDir, options.include, options.cache, options.changedPaths, options.effect);
   const diagnostics = [
     ...graph.diagnostics ?? [],
     ...validateGraph(graph, options),
@@ -249069,6 +249283,7 @@ function optionsKeyOf(options) {
     openApi: options.openApi,
     generatePermissions: options.generatePermissions,
     typeSafety: options.typeSafety,
+    effect: options.effect,
     treeShakeUnusedProviders: options.treeShakeUnusedProviders,
     graphql: options.graphql
   });
@@ -249400,7 +249615,12 @@ var DEFAULT_SUPACLOUD_CONFIG = {
   effect: {
     requireRouteEffects: true,
     requireErrorMappings: true,
-    requireDependencies: true
+    requireDependencies: true,
+    requireTaggedErrorTypes: true,
+    requireExactDependencyTypes: true,
+    requireTimeoutForDependencies: true,
+    forbidDirectRuntimeExecution: true,
+    forbidDirectThrows: true
   }
 };
 function defineSupacloudConfig(config = {}) {
@@ -249472,10 +249692,28 @@ function validateGovernanceConfig(config) {
       throw new Error(`${key} must be a boolean.`);
   }
   if (config.effect !== undefined) {
-    if (!isRecord(config.effect) || Object.keys(config.effect).some((key) => !["requireRouteEffects", "requireErrorMappings", "requireDependencies"].includes(key))) {
-      throw new Error("effect accepts requireRouteEffects, requireErrorMappings and requireDependencies.");
-    }
-    for (const key of ["requireRouteEffects", "requireErrorMappings", "requireDependencies"]) {
+    if (!isRecord(config.effect) || Object.keys(config.effect).some((key) => ![
+      "requireRouteEffects",
+      "requireErrorMappings",
+      "requireDependencies",
+      "requireTaggedErrorTypes",
+      "requireExactDependencyTypes",
+      "requireTimeoutForDependencies",
+      "forbidDirectRuntimeExecution",
+      "forbidDirectThrows"
+    ].includes(key))) {
+      throw new Error("effect contains an unsupported governance option.");
+    }
+    for (const key of [
+      "requireRouteEffects",
+      "requireErrorMappings",
+      "requireDependencies",
+      "requireTaggedErrorTypes",
+      "requireExactDependencyTypes",
+      "requireTimeoutForDependencies",
+      "forbidDirectRuntimeExecution",
+      "forbidDirectThrows"
+    ]) {
       if (config.effect[key] !== undefined && typeof config.effect[key] !== "boolean") {
         throw new Error(`effect.${key} must be boolean.`);
       }
@@ -249650,7 +249888,7 @@ var starter_metadata_default = {
   generatedBy: "supacloud/starter-metadata-v1",
   packages: {
     compiler: {
-      version: "0.41.0"
+      version: "0.42.0"
     },
     app: {
       version: "0.24.0",
@@ -249659,7 +249897,7 @@ var starter_metadata_default = {
       }
     },
     elysia: {
-      version: "0.28.0"
+      version: "0.29.0"
     },
     commands: {
       version: "0.9.1"
@@ -250013,7 +250251,7 @@ function baseFiles(name, sdkDependencies) {
       dependencies: {
         "@supacloud/app": `^${appMetadata.version}`,
         "@supacloud/elysia": `^${elysiaMetadata.version}`,
-        effect: "3.22.1",
+        effect: "4.0.2",
         elysia: "2.0.0-beta.21",
         ...sdkDependencies ?? { rxjs: appMetadata.dependencies.rxjs }
       },
@@ -250062,6 +250300,11 @@ export default defineSupacloudConfig({
     requireRouteEffects: true,
     requireErrorMappings: true,
     requireDependencies: true,
+    requireTaggedErrorTypes: true,
+    requireExactDependencyTypes: true,
+    requireTimeoutForDependencies: true,
+    forbidDirectRuntimeExecution: true,
+    forbidDirectThrows: true,
   },
   typeSafety: { scanProductionSource: true, noAnyInGenerated: true },
   disallowControllerDirectDb: true,
@@ -250091,7 +250334,7 @@ export const CreateOrderBody = t.Object({ name: t.String({ minLength: 1 }) });
 export const OrderResult = t.Object({ id: t.String(), name: t.String() });
 export const HealthResult = t.Object({ ok: t.Boolean() });
 `,
-    "src/orders/orders.ts": `import * as Effect from "effect/Effect";
+    "src/orders/orders.ts": `import { Effect } from "effect";
 import { Body, Controller, Get, Param, Post, defineFeatureSlice } from "@supacloud/app";
 import { status } from "elysia";
 import { OrderParams, CreateOrderBody, OrderResult, HealthResult } from "./contracts";
@@ -250292,7 +250535,7 @@ function minimalTemplate(name, sdkDependencies) {
     "src/features/health/contracts.ts": `import { t } from "elysia";
 export const HealthResult = t.Object({ ok: t.Boolean() });
 `,
-    "src/features/health/health.ts": `import * as Effect from "effect/Effect";
+    "src/features/health/health.ts": `import { Effect } from "effect";
 import { Controller, Get, Module } from "@supacloud/app/core";
 import { HealthResult } from "./contracts";
 @Controller("/health")
@@ -250307,7 +250550,7 @@ export class HealthController {
 @Module({ name: "health", tags: ["type:feature"], controllers: [HealthController] })
 export class HealthModule {}
 `,
-    "src/features/health/health.test.ts": `import * as Effect from "effect/Effect";
+    "src/features/health/health.test.ts": `import { Effect } from "effect";
 import { expect, test } from "bun:test";
 import { HealthController } from "./health";
 
@@ -250837,7 +251080,7 @@ export async function createDeliveryWorker(modules: CompiledModule[], lifecycle:
 `;
 
 // src/shared/tools/app-starter-upload.ts
-var STARTER_UPLOAD_FEATURE = `import * as Effect from "effect/Effect";
+var STARTER_UPLOAD_FEATURE = `import { Effect } from "effect";
 import { Body, Controller, Inject, Injectable, Param, Post, DB_CLIENT, REQUEST_CONTEXT } from "@supacloud/app";
 import { ApplicationError } from "@supacloud/elysia";
 import { UploadBody, UploadLocation, UploadParams, UploadResult } from "./contracts";
@@ -250845,6 +251088,17 @@ import { UploadBody, UploadLocation, UploadParams, UploadResult } from "./contra
 export interface ReviewUploadInput { reviewId: string; artifactId: string; expectedVersion: number }
 export interface ReviewUploadLocation { artifactId: string; bucketId: string; objectPath: string }
 export interface ReviewUploadResult { artifactId: string; runId: string; objectPath: string; sha256: string; bytes: number }
+type PreviewUploadError =
+  | { readonly _tag: "AUTHENTICATION_REQUIRED" }
+  | { readonly _tag: "UPLOAD_INPUT_INVALID" }
+  | { readonly _tag: "UPLOAD_DENIED" }
+  | { readonly _tag: "UPLOADS_UNAVAILABLE" };
+type RegisterUploadError =
+  | PreviewUploadError
+  | { readonly _tag: "UPLOAD_CONTENT_INVALID" }
+  | { readonly _tag: "COMMAND_IDEMPOTENCY_CONFLICT" }
+  | { readonly _tag: "COMMAND_REJECTED" }
+  | { readonly _tag: "UPLOAD_OUTCOME_UNKNOWN" };
 export interface ReviewUploadPort {
   previewUpload(context: unknown, input: ReviewUploadInput): Promise<ReviewUploadLocation>;
   registerUpload(context: unknown, input: ReviewUploadInput): Promise<ReviewUploadResult>;
@@ -250884,7 +251138,7 @@ export class ReviewUploadsController {
       retry: "none",
     },
   })
-  preview(@Param("id") id: string, @Body() body: { artifactId: string; expectedVersion: number }): Effect.Effect<ReviewUploadLocation, unknown, never> {
+  preview(@Param("id") id: string, @Body() body: { artifactId: string; expectedVersion: number }): Effect.Effect<ReviewUploadLocation, PreviewUploadError, never> {
     return Effect.promise(() => this.uploads.preview({ reviewId: id, artifactId: body.artifactId, expectedVersion: body.expectedVersion }));
   }
   @Post("/:id/attachment-registration", {
@@ -250907,7 +251161,7 @@ export class ReviewUploadsController {
       retry: "none",
     },
   })
-  register(@Param("id") id: string, @Body() body: { artifactId: string; expectedVersion: number }): Effect.Effect<ReviewUploadResult, unknown, never> {
+  register(@Param("id") id: string, @Body() body: { artifactId: string; expectedVersion: number }): Effect.Effect<ReviewUploadResult, RegisterUploadError, never> {
     return Effect.promise(() => this.uploads.register({ reviewId: id, artifactId: body.artifactId, expectedVersion: body.expectedVersion }));
   }
 }
@@ -251619,7 +251873,7 @@ function appStarterFiles(name) {
         "drizzle-orm": dbMetadata.peerDependencies["drizzle-orm"],
         "@supacloud/js": `^${sdkMetadata.version}`,
         "@supabase/supabase-js": sdkMetadata.peerDependencies["@supabase/supabase-js"],
-        effect: "3.22.1",
+        effect: "4.0.2",
         elysia: "2.0.0-beta.21",
         rxjs: appMetadata2.dependencies.rxjs
       },
@@ -251679,6 +251933,11 @@ export default defineSupacloudConfig({
     requireRouteEffects: true,
     requireErrorMappings: true,
     requireDependencies: true,
+    requireTaggedErrorTypes: true,
+    requireExactDependencyTypes: true,
+    requireTimeoutForDependencies: true,
+    forbidDirectRuntimeExecution: true,
+    forbidDirectThrows: true,
   },
   typeSafety: { scanProductionSource: true, noAnyInGenerated: true },
   disallowControllerDirectDb: true,
@@ -251880,7 +252139,7 @@ export function createCompiledModules(): never {
   throw new Error("Run bun run compile before starting the application");
 }
 `,
-    "src/review/review.ts": `import * as Effect from "effect/Effect";
+    "src/review/review.ts": `import { Effect } from "effect";
 import {
   Body, Command, Controller, DB_CLIENT, Get, Inject, Param, Post,
   defineFeatureSlice, defineFeatureSpec, type Aspect,
@@ -251947,6 +252206,17 @@ export class ApproveReview {
   }
 }
 
+type ReviewError =
+    | { readonly _tag: "AUTHENTICATION_REQUIRED" }
+    | { readonly _tag: "REVIEW_NOT_FOUND" }
+    | { readonly _tag: "REVIEW_PERMISSION_DENIED" }
+    | { readonly _tag: "REVIEW_CONFLICT" }
+    | { readonly _tag: "FEATURE_TRANSITION_CONFLICT" }
+    | { readonly _tag: "COMMAND_IDEMPOTENCY_CONFLICT" }
+    | { readonly _tag: "COMMAND_REJECTED" }
+    | { readonly _tag: "REVIEW_COMMAND_UNSUPPORTED" }
+    | { readonly _tag: "COMMAND_OUTCOME_UNKNOWN" };
+
 @Controller("/reviews")
 export class ReviewController {
   constructor(@Inject(ApproveReview) private readonly approveReview: ApproveReview) {}
@@ -251979,7 +252249,7 @@ export class ReviewController {
       retry: "none",
     },
   })
-  approve(@Param("id") id: string, @Body() body: { expectedVersion: number }): Effect.Effect<Review, unknown, never> {
+  approve(@Param("id") id: string, @Body() body: { expectedVersion: number }): Effect.Effect<Review, ReviewError, never> {
     return Effect.promise(() => this.approveReview.execute(id, body.expectedVersion));
   }
 }
@@ -252519,7 +252789,7 @@ export class ${className}Service {
     }
 }
 `,
-    [`${name}.controller.ts`]: `import * as Effect from "effect/Effect";
+    [`${name}.controller.ts`]: `import { Effect } from "effect";
 import { Controller, Get, Inject, Param } from "@supacloud/app";
 import { ${className}Params, ${className}Response, type ${className}Result } from "./${name}.model";
 import { ${className}Service } from "./${name}.service";
@@ -252533,7 +252803,7 @@ export class ${className}Controller {
         responses: { 200: ${className}Response },
         effect: { required: true, dependencies: [], errors: [], retry: "none" },
     })
-    find(@Param("id") id: string): Effect.Effect<${className}Result, unknown, never> {
+    find(@Param("id") id: string): Effect.Effect<${className}Result, never, never> {
         return Effect.promise(() => this.service.find(id));
     }
 }
@@ -252569,7 +252839,7 @@ test("${name} preserves permission denial without a privileged fallback", async
     await expect(service.find("example")).rejects.toBe(denied);
 });
 `,
-    [`${name}.controller.test.ts`]: `import * as Effect from "effect/Effect";
+    [`${name}.controller.test.ts`]: `import { Effect } from "effect";
 import { expect, test } from "bun:test";
 import { ${className}Controller } from "./${name}.controller";
 
@@ -257123,7 +257393,7 @@ function registerRemoteDevTools(server2, options = {}) {
 // package.json
 var package_default = {
   name: "@supacloud/cli",
-  version: "0.73.0",
+  version: "0.74.0",
   description: "Project-scoped CLI for SupaCloud users",
   type: "module",
   main: "./dist/index.js",
@@ -257157,7 +257427,7 @@ var package_default = {
     directory: "packages/cli"
   },
   dependencies: {
-    "@supacloud/compiler": "^0.41.0",
+    "@supacloud/compiler": "^0.42.0",
     "@supacloud/delivery": "0.8.0",
     "@supacloud/db": "^0.14.0",
     fflate: "^0.8.3",
@@ -257170,7 +257440,7 @@ var package_default = {
   devDependencies: {
     "@supacloud/elysia": "^0.24.1",
     "@types/bun": "^1.4.2",
-    effect: "3.22.1",
+    effect: "4.0.2",
     elysia: "2.0.0-beta.21",
     typescript: "^7.0.2"
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@supacloud/cli",
-  "version": "0.73.0",
+  "version": "0.74.0",
   "description": "Project-scoped CLI for SupaCloud users",
   "type": "module",
   "main": "./dist/index.js",
@@ -34,7 +34,7 @@
     "directory": "packages/cli"
   },
   "dependencies": {
-    "@supacloud/compiler": "^0.41.0",
+    "@supacloud/compiler": "^0.42.0",
     "@supacloud/delivery": "0.8.0",
     "@supacloud/db": "^0.14.0",
     "fflate": "^0.8.3",
@@ -47,7 +47,7 @@
   "devDependencies": {
     "@supacloud/elysia": "^0.24.1",
     "@types/bun": "^1.4.2",
-    "effect": "3.22.1",
+    "effect": "4.0.2",
     "elysia": "2.0.0-beta.21",
     "typescript": "^7.0.2"
   }