apps 0.0.1-beta.10 → 0.0.1-beta.100

package/js/{chunk-VFZKSM3T.js → chunk-4X2UI4R2.js}

@@ -1,13 +1,13 @@
 import {
   Schema_exports
-} from "./chunk-CDL5PM2Q.js";
+} from "./chunk-ZKDXML77.js";
 
 // src/contracts/ui-auth.ts
-var AppSignInId = Schema_exports.String.check(Schema_exports.isPattern(/^[a-f0-9]{64}$/)).pipe(
+var AppSignInId = Schema_exports.String.check(Schema_exports.isPattern(/^[a-f0-9]{64}$/u)).pipe(
   Schema_exports.brand("AppSignInId")
 );
 var AppSignInCode = Schema_exports.RedactedFromValue(
-  Schema_exports.String.check(Schema_exports.isPattern(/^[a-f0-9]{64}$/))
+  Schema_exports.String.check(Schema_exports.isPattern(/^[a-f0-9]{64}$/u))
 );
 var AppReturnPath = Schema_exports.String.check(
   Schema_exports.isMaxLength(8192),

package/js/chunk-5C6RAGAS.js

@@ -0,0 +1,335 @@
+import {
+  appInvocationFetch
+} from "./chunk-VCYWAA4N.js";
+import {
+  fromPromise,
+  method,
+  toPromise
+} from "./chunk-7STIP5CS.js";
+import {
+  CacheAcquired,
+  CacheEntry,
+  CacheError,
+  cacheLimits,
+  scopedSlots
+} from "./chunk-4UPC36ZL.js";
+import {
+  decoderOf
+} from "./chunk-VAI3EVCS.js";
+import {
+  captureTelemetry,
+  owned,
+  ownedBy
+} from "./chunk-URKOTNDA.js";
+import {
+  Clock_exports,
+  Duration_exports,
+  Effect_exports,
+  Exit_exports,
+  Schema_exports
+} from "./chunk-ZKDXML77.js";
+
+// ../app-cache/src/index.ts
+var canonical = (value) => {
+  if (Array.isArray(value)) return `[${value.map(canonical).join(",")}]`;
+  if (value !== null && typeof value === "object")
+    return `{${Object.entries(value).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([key, item]) => `${JSON.stringify(key)}:${canonical(item)}`).join(",")}}`;
+  return JSON.stringify(value);
+};
+var cacheKey = (key) => Effect_exports.gen(function* () {
+  const parsed = yield* Schema_exports.decodeUnknownEffect(Schema_exports.Json)(key).pipe(
+    Effect_exports.mapError(() => new CacheError({ reason: "invalid" }))
+  );
+  const bytes = new TextEncoder().encode(canonical(parsed));
+  if (bytes.byteLength > cacheLimits.keyBytes)
+    return yield* new CacheError({ reason: "capacity", limit: "keyBytes" });
+  const hash = yield* Effect_exports.tryPromise({
+    try: () => crypto.subtle.digest("SHA-256", bytes),
+    catch: () => new CacheError({ reason: "invalid" })
+  });
+  return [...new Uint8Array(hash)].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+});
+var makeCache = (host, background, scope = "shared", deadline, leaseWait = (effect) => effect) => {
+  const transport = (command) => host(command).pipe(
+    Effect_exports.withSpan("app.cache.command", {
+      attributes: { "cache.operation": command.operation }
+    })
+  );
+  const keyOf = (key) => cacheKey([scope, key]);
+  const readKeys = (keys) => transport({ operation: "read", keys }).pipe(
+    Effect_exports.flatMap(Schema_exports.decodeUnknownEffect(Schema_exports.Array(Schema_exports.NullOr(CacheEntry)))),
+    Effect_exports.mapError(() => new CacheError({ reason: "storage" }))
+  );
+  const durations = (freshFor, staleFor = 0) => Effect_exports.try({
+    try: () => ({
+      fresh: Duration_exports.toMillis(Duration_exports.fromInputUnsafe(freshFor)),
+      stale: Duration_exports.toMillis(Duration_exports.fromInputUnsafe(staleFor))
+    }),
+    catch: () => new CacheError({ reason: "invalid" })
+  }).pipe(
+    Effect_exports.flatMap(
+      ({ fresh, stale }) => ![fresh, stale].every((value) => Number.isFinite(value) && value >= 0) ? Effect_exports.fail(new CacheError({ reason: "invalid" })) : (
+        // The cache keeps nothing past its retention: a longer lifetime loses staleness first.
+        Effect_exports.succeed({
+          fresh: Math.min(fresh, cacheLimits.retentionMs),
+          stale: Math.max(0, Math.min(stale, cacheLimits.retentionMs - fresh))
+        })
+      )
+    )
+  );
+  const get = (options, refresh, also = () => []) => Effect_exports.gen(function* () {
+    const key = yield* keyOf(options.key);
+    const extra = also(key);
+    const reads = extra.length === 0 ? void 0 : yield* Effect_exports.forEach(extra, keyOf);
+    const withReads = (value, entries) => ({
+      value,
+      key,
+      reads: entries
+    });
+    const loaded = (value) => ({ value, key, reads: void 0 });
+    const { fresh, stale } = yield* durations(options.freshFor, options.staleFor);
+    const decode = (value) => Schema_exports.decodeUnknownEffect(options.schema)(value);
+    const load = (lease) => Effect_exports.gen(function* () {
+      const value = yield* options.load.pipe(Effect_exports.flatMap(decode));
+      const json = yield* Schema_exports.decodeUnknownEffect(Schema_exports.Json)(value).pipe(
+        Effect_exports.mapError(() => new CacheError({ reason: "invalid" }))
+      );
+      const now = yield* Clock_exports.currentTimeMillis;
+      const published = yield* transport({
+        operation: "publish",
+        key,
+        lease,
+        entry: {
+          value: json,
+          version: crypto.randomUUID(),
+          freshUntil: now + fresh,
+          staleUntil: now + fresh + stale
+        }
+      }).pipe(Effect_exports.withSpan("app.cache.publish"));
+      if (published !== true) return yield* new CacheError({ reason: "unavailable" });
+      return value;
+    }).pipe(
+      Effect_exports.withSpan("app.cache.load"),
+      Effect_exports.timeout(cacheLimits.loadTimeoutMs),
+      // Publishing clears the lease in the same transaction. Only an unpublished load releases it.
+      Effect_exports.onExit(
+        (exit) => Exit_exports.isSuccess(exit) ? Effect_exports.void : transport({ operation: "release", key, lease }).pipe(
+          Effect_exports.catch(() => Effect_exports.void)
+        )
+      )
+    );
+    const waitUntil = Math.min(
+      (yield* Clock_exports.currentTimeMillis) + cacheLimits.waitMs,
+      deadline ?? Number.POSITIVE_INFINITY
+    );
+    let initialVersion;
+    const attempt = Effect_exports.gen(function* () {
+      const acquired = yield* transport({
+        operation: "acquire",
+        key,
+        refresh,
+        ...initialVersion === void 0 ? {} : { version: initialVersion },
+        ...reads === void 0 ? {} : { reads }
+      }).pipe(
+        Effect_exports.flatMap(
+          (reply) => Schema_exports.decodeUnknownEffect(CacheAcquired)(reply).pipe(
+            Effect_exports.mapError(() => new CacheError({ reason: "storage" }))
+          )
+        )
+      );
+      const { entry, lease } = acquired;
+      const together = acquired.reads?.length === reads?.length ? acquired.reads : void 0;
+      const now = yield* Clock_exports.currentTimeMillis;
+      if (initialVersion === void 0) initialVersion = entry?.version ?? null;
+      const refreshed = refresh && entry !== null && entry.version !== initialVersion;
+      if (entry !== null && (refreshed || !refresh && lease === null && now < entry.freshUntil))
+        return { next: "fresh", entry, together };
+      const kept = !refresh && entry !== null && now < entry.staleUntil;
+      if (kept && options.stale !== "revalidate")
+        return { next: "stale", entry, lease, together };
+      if (lease !== null) return { next: "load", lease, kept };
+      if (now >= waitUntil) return { next: "local" };
+      return { next: "wait" };
+    });
+    let decided = yield* attempt;
+    if (decided.next === "wait")
+      decided = yield* Effect_exports.gen(function* () {
+        while (true) {
+          yield* Effect_exports.sleep("100 millis");
+          const next = yield* attempt;
+          if (next.next !== "wait") return next;
+        }
+      }).pipe(leaseWait);
+    switch (decided.next) {
+      case "fresh":
+        yield* Effect_exports.annotateCurrentSpan("cache.result", "fresh");
+        return withReads(yield* decode(decided.entry.value), decided.together);
+      case "stale":
+        yield* Effect_exports.annotateCurrentSpan("cache.result", "stale");
+        if (decided.lease !== null) yield* background(load(decided.lease).pipe(Effect_exports.asVoid));
+        return withReads(yield* decode(decided.entry.value), decided.together);
+      case "load":
+        yield* Effect_exports.annotateCurrentSpan("cache.result", decided.kept ? "revalidated" : "miss");
+        return loaded(yield* load(decided.lease));
+      case "local":
+        yield* Effect_exports.annotateCurrentSpan("cache.result", "local");
+        return loaded(
+          yield* options.load.pipe(
+            Effect_exports.flatMap(decode),
+            Effect_exports.timeout(cacheLimits.loadTimeoutMs),
+            Effect_exports.withSpan("app.cache.load", { attributes: { "cache.load.leased": false } })
+          )
+        );
+    }
+  }).pipe(Effect_exports.withSpan("app.cache.get"));
+  return {
+    /** Read arbitrary retained JSON entries without initiating a refresh. Missing and null are distinct. */
+    read: (keys) => Effect_exports.forEach(keys, keyOf).pipe(Effect_exports.flatMap(readKeys)),
+    /** Publish bounded immutable parts before publishing the manifest that references them. */
+    write: (entries, retention) => Effect_exports.gen(function* () {
+      const { fresh } = yield* durations(retention);
+      const now = yield* Clock_exports.currentTimeMillis;
+      const values = yield* Effect_exports.forEach(
+        entries,
+        ({ key, value }) => Effect_exports.gen(function* () {
+          return {
+            key: yield* keyOf(key),
+            entry: {
+              value,
+              version: crypto.randomUUID(),
+              freshUntil: now + fresh,
+              staleUntil: now + fresh
+            }
+          };
+        })
+      );
+      yield* transport({ operation: "write", entries: values });
+    }),
+    /** Revoke retained data and any loader's right to publish its in-flight result. */
+    invalidate: (key) => keyOf(key).pipe(
+      Effect_exports.flatMap((key2) => transport({ operation: "invalidate", key: key2 })),
+      Effect_exports.asVoid
+    ),
+    /**
+     * Read fresh data, refresh stale data in the background (or first, with `stale: "revalidate"`),
+     * or wait for the lease owner.
+     */
+    get: (options) => get(options, false).pipe(Effect_exports.map(({ value }) => value)),
+    /**
+     * `get`, also reading the keys of this scope that `keys` names in the same round trip. `keys`
+     * gets the entry's store key, which is unique to this scope and key, so a caller can remember
+     * what it read under it. `reads` holds their entries, undecoded and in order, when the value
+     * was read from the store; it is undefined when the value was loaded or the store did not read
+     * them, and the caller then reads what it still needs.
+     */
+    getWith: (options, keys) => get(options, false, keys),
+    /** Force one awaited refresh without removing the retained value. Concurrent refreshes share a load. */
+    revalidate: (options) => get(options, true).pipe(Effect_exports.map(({ value }) => value))
+  };
+};
+
+// src/implementation/cache.ts
+var getWithReads = /* @__PURE__ */ Symbol("executor.cache.getWithReads");
+var unavailableCache = {
+  transport: () => Effect_exports.fail(new CacheError({ reason: "unavailable" })),
+  background: () => Effect_exports.die(new Error("Cache background runner is unavailable"))
+};
+var authorCache = (host, accounts, signal, telemetry, deadline) => {
+  const scoped = (scope, callerSignal = signal, services = telemetry) => {
+    const cache = makeCache(
+      host.transport,
+      // A refresh handed to the background runs beside the caller, which does not wait on it.
+      (task) => host.background(task.pipe(owned("background", "app.cache.refresh"))),
+      scope,
+      deadline,
+      // Waiting on another caller's load is waiting, not Executor's work.
+      (wait) => wait.pipe(Effect_exports.withSpan("app.cache.lease.wait", ownedBy("lease")))
+    );
+    const getOptions = (options) => ({
+      key: options.key,
+      schema: decoderOf(options.schema),
+      freshFor: options.freshFor,
+      ...options.staleFor === void 0 ? {} : { staleFor: options.staleFor },
+      ...options.stale === void 0 ? {} : { stale: options.stale },
+      load: Effect_exports.acquireUseRelease(
+        Effect_exports.sync(() => new AbortController()),
+        (controller) => Effect_exports.all([appInvocationFetch(controller.signal), captureTelemetry]).pipe(
+          Effect_exports.flatMap(
+            ([fetch, loading]) => fromPromise(
+              method(options, "load"),
+              "loader"
+            )({
+              fetch,
+              signal: controller.signal,
+              cache: scoped(scope, controller.signal, loading.context)
+            })
+          )
+        ),
+        (controller) => Effect_exports.sync(() => controller.abort())
+      )
+    });
+    const load = (read, given) => cache[read](getOptions(given));
+    const decodeEntries = (entries, schema) => Effect_exports.forEach(
+      entries,
+      (entry) => entry === null ? Effect_exports.succeed(void 0) : Schema_exports.decodeUnknownEffect(decoderOf(schema))(entry.value)
+    );
+    const service = (method2, operation) => toPromise(
+      (...args) => operation(...args).pipe(
+        owned("executor", "app.cache.call", { attributes: { "cache.method": method2 } })
+      ),
+      callerSignal,
+      services
+    );
+    const authored = {
+      get: service("get", (options) => load("get", options)),
+      revalidate: service(
+        "revalidate",
+        (options) => load("revalidate", options)
+      ),
+      read: service(
+        "read",
+        (key, schema) => cache.read([key]).pipe(
+          Effect_exports.flatMap((entries) => {
+            const entry = entries[0];
+            return entry === void 0 || entry === null ? Effect_exports.succeed(void 0) : Schema_exports.decodeUnknownEffect(decoderOf(schema))(entry.value);
+          })
+        )
+      ),
+      readMany: service(
+        "readMany",
+        (keys, schema) => cache.read(keys).pipe(Effect_exports.flatMap((entries) => decodeEntries(entries, schema)))
+      ),
+      write: service("write", cache.write),
+      invalidate: service("invalidate", cache.invalidate),
+      forAccount: (account) => {
+        const bound = scopedSlots(accounts).flatMap(([, value]) => Array.isArray(value) ? value : [value]).find((value) => value.id === account.id);
+        if (bound === void 0) throw new CacheError({ reason: "invalid" });
+        return scoped(
+          { account: bound.id, method: bound.method, generation: bound.generation },
+          callerSignal,
+          services
+        );
+      }
+    };
+    return Object.defineProperty(authored, getWithReads, {
+      value: service(
+        "get",
+        (given, keys) => cache.getWith(getOptions(given), keys).pipe(
+          Effect_exports.map(({ value, key, reads }) => ({
+            value,
+            key,
+            reads: reads?.map((entry) => entry === null ? void 0 : entry.value)
+          }))
+        )
+      )
+    });
+  };
+  return scoped("shared");
+};
+
+export {
+  cacheKey,
+  getWithReads,
+  unavailableCache,
+  authorCache
+};

package/js/{chunk-KUMBKVJD.js → chunk-62NVUKED.js}

@@ -1,9 +1,9 @@
 import {
   appSignInCallbackPath
-} from "./chunk-VFZKSM3T.js";
+} from "./chunk-4X2UI4R2.js";
 import {
   HttpServerResponse_exports
-} from "./chunk-UK573G7W.js";
+} from "./chunk-ACQXVKVQ.js";
 
 // src/implementation/ui-auth.ts
 var appPrivateHeaders = {

package/js/chunk-74H25C4X.js

@@ -0,0 +1,95 @@
+import {
+  JsonValue,
+  withLegacyKeys
+} from "./chunk-7HG422GB.js";
+import {
+  HttpApiEndpoint_exports,
+  HttpApiGroup_exports,
+  HttpApiSchema_exports,
+  HttpApi_exports
+} from "./chunk-DILSCQPJ.js";
+import {
+  Schema_exports
+} from "./chunk-ZKDXML77.js";
+
+// src/contracts/ui.ts
+var UiContextFields = Schema_exports.Struct({
+  version: Schema_exports.NonEmptyString,
+  accounts: Schema_exports.optional(
+    Schema_exports.Record(Schema_exports.NonEmptyString, Schema_exports.Array(Schema_exports.NonEmptyString))
+  )
+});
+var UiContext = UiContextFields.pipe(withLegacyKeys({ version: "deployment" }));
+var UiOperation = Schema_exports.Struct({
+  ...UiContextFields.fields,
+  name: Schema_exports.NonEmptyString,
+  input: JsonValue
+}).pipe(withLegacyKeys({ version: "deployment" }));
+var UiUnauthorized = class extends Schema_exports.TaggedError()(
+  "UiUnauthorized",
+  {},
+  { httpApiStatus: 401 }
+) {
+};
+var UiForbidden = class extends Schema_exports.TaggedError()(
+  "UiForbidden",
+  {},
+  { httpApiStatus: 403 }
+) {
+};
+var UiVersionChanged = class extends Schema_exports.TaggedError()(
+  "UiDeploymentChanged",
+  {},
+  { httpApiStatus: 409 }
+) {
+};
+var UiFailed = class extends Schema_exports.TaggedError()(
+  "UiFailed",
+  {
+    reason: Schema_exports.Literals(["unavailable", "operation_failed", "account_required"])
+  },
+  { httpApiStatus: 422 }
+) {
+};
+var UiSnapshot = Schema_exports.Union([
+  Schema_exports.Struct({
+    type: Schema_exports.Literal("snapshot"),
+    value: JsonValue,
+    trace: Schema_exports.optional(Schema_exports.Unknown)
+  }),
+  Schema_exports.Struct({ type: Schema_exports.Literal("failure"), error: UiFailed }),
+  Schema_exports.Struct({ type: Schema_exports.Literal("heartbeat") })
+]);
+var errors = [UiUnauthorized, UiForbidden, UiVersionChanged, UiFailed];
+var AppUiApi = HttpApi_exports.make("app-ui").add(
+  HttpApiGroup_exports.make("ui").add(
+    HttpApiEndpoint_exports.post("query", "/_executor/api/query", {
+      payload: UiOperation,
+      success: JsonValue,
+      error: errors
+    })
+  ).add(
+    HttpApiEndpoint_exports.post("mutate", "/_executor/api/mutate", {
+      payload: UiOperation,
+      success: JsonValue,
+      error: errors
+    })
+  ).add(
+    HttpApiEndpoint_exports.post("subscribe", "/_executor/api/subscribe", {
+      payload: UiOperation,
+      success: HttpApiSchema_exports.StreamSse({ data: UiSnapshot, error: Schema_exports.Union(errors) }),
+      error: errors
+    })
+  )
+);
+
+export {
+  UiContext,
+  UiOperation,
+  UiUnauthorized,
+  UiForbidden,
+  UiVersionChanged,
+  UiFailed,
+  UiSnapshot,
+  AppUiApi
+};

package/js/chunk-7HG422GB.js

@@ -0,0 +1,90 @@
+import {
+  SchemaTransformation_exports,
+  Schema_exports
+} from "./chunk-ZKDXML77.js";
+
+// src/contracts/schema.ts
+var JsonValue = Schema_exports.Json;
+var JsonObject = Schema_exports.Record(Schema_exports.String, JsonValue);
+var AccountId = Schema_exports.String.pipe(
+  Schema_exports.check(Schema_exports.isStartingWith("acc_"), Schema_exports.isMinLength(5)),
+  Schema_exports.brand("acc")
+);
+var HttpUrl = Schema_exports.String.check(
+  Schema_exports.makeFilter((value) => {
+    try {
+      const url = new URL(value);
+      return url.protocol === "https:" || url.protocol === "http:";
+    } catch {
+      return false;
+    }
+  })
+);
+var DeclarationIssue = Schema_exports.Struct({
+  path: Schema_exports.Array(Schema_exports.String),
+  message: Schema_exports.String
+});
+var DeclarationInvalid = class extends Schema_exports.TaggedError()(
+  "DeclarationInvalid",
+  { declaration: Schema_exports.String, issues: Schema_exports.Array(DeclarationIssue) }
+) {
+  get message() {
+    const problems = this.issues.map(
+      (issue) => issue.path.length === 0 ? issue.message : `${issue.path.join(".")}: ${issue.message}`
+    );
+    return `The ${this.declaration} declaration is invalid. ${problems.join("; ")}`;
+  }
+};
+var ValidationError = class extends Schema_exports.TaggedError()("ValidationError", {}) {
+  get message() {
+    return "Value did not match the schema";
+  }
+};
+
+// ../utils/src/legacy-keys.ts
+var withLegacyKeys = (mapping) => (self) => {
+  const renamed = Object.entries(mapping).filter(
+    (entry) => typeof entry[1] === "string"
+  );
+  const fields = {};
+  for (const key of Object.keys(self.fields)) {
+    const encoded = Schema_exports.toEncoded(self.fields[key]);
+    const legacy = mapping[key];
+    fields[key] = typeof legacy === "string" ? Schema_exports.optionalKey(encoded) : encoded;
+    if (typeof legacy === "string") fields[legacy] = Schema_exports.optionalKey(encoded);
+  }
+  return Schema_exports.Struct(fields).pipe(
+    Schema_exports.decodeTo(
+      self,
+      SchemaTransformation_exports.transform({
+        decode: (input) => {
+          const output = { ...input };
+          for (const [key, legacy] of renamed) {
+            if (!Object.hasOwn(output, key) && Object.hasOwn(output, legacy)) {
+              output[key] = output[legacy];
+            }
+            delete output[legacy];
+          }
+          return output;
+        },
+        encode: (input) => {
+          const output = { ...input };
+          for (const [key, legacy] of renamed) {
+            if (Object.hasOwn(output, key)) output[legacy] = output[key];
+          }
+          return output;
+        }
+      })
+    )
+  );
+};
+
+export {
+  JsonValue,
+  JsonObject,
+  AccountId,
+  HttpUrl,
+  DeclarationInvalid,
+  ValidationError,
+  withLegacyKeys
+};