apps 0.0.1-beta.0 → 0.0.1-beta.1

package/js/{chunk-BPEFS4YF.js → chunk-2HHMABB6.js}

@@ -1,12 +1,13 @@
 import {
   ValidationError
-} from "./chunk-36DNRFZQ.js";
+} from "./chunk-SATWJKN6.js";
 import {
   Effect_exports,
+  SchemaGetter_exports,
   SchemaIssue_exports,
   SchemaParser_exports,
   Schema_exports
-} from "./chunk-2OTCEKL2.js";
+} from "./chunk-FW5HBOIK.js";
 
 // ../../node_modules/.bun/@cfworker+json-schema@4.1.1/node_modules/@cfworker/json-schema/dist/esm/deep-compare-strict.js
 function deepCompareStrict(a, b) {
@@ -1129,12 +1130,30 @@ function object(fields) {
   const entries = Object.entries(fields).map(
     ([key, field]) => [key, decoderOf(field)]
   );
-  const decoder = Schema_exports.Struct(Object.fromEntries(entries));
+  const decoder = entries.length === 0 ? withJsonSchemaDocument(
+    // Native Struct({}) accepts every non-null value and retains undeclared fields.
+    Schema_exports.Record(Schema_exports.String, Schema_exports.Unknown).pipe(
+      Schema_exports.decodeTo(Schema_exports.Record(Schema_exports.String, Schema_exports.Never), {
+        decode: SchemaGetter_exports.transform(() => ({})),
+        encode: SchemaGetter_exports.transform((value) => value)
+      })
+    ),
+    { type: "object", properties: {}, additionalProperties: false }
+  ) : Schema_exports.Struct(Object.fromEntries(entries));
   return { ...wrap(decoder, false), fields: Object.freeze({ ...fields }) };
 }
 var ImportedJsonSchema = /* @__PURE__ */ Symbol("apps.JsonSchemaDocument");
 var importedJsonSchema = (decoder) => ImportedJsonSchema in decoder ? decoder[ImportedJsonSchema] : void 0;
 var withJsonSchemaDocument = (decoder, document) => Object.assign(decoder, { [ImportedJsonSchema]: document });
+var once = (compute) => {
+  let state;
+  return () => (state ??= { value: compute() }).value;
+};
+var withLazyJsonSchemaDocument = (decoder, document) => Object.defineProperty(decoder, ImportedJsonSchema, {
+  configurable: true,
+  enumerable: true,
+  get: once(document)
+});
 var nestJsonSchema = (input, pointer) => {
   const document = structuredClone(input);
   const lookup = dereference(document);
@@ -1232,6 +1251,40 @@ function interpretedDocument(value) {
   }
   return Object.fromEntries(entries);
 }
+var containerKeywords = /* @__PURE__ */ new Set([
+  "$ref",
+  "$recursiveRef",
+  "$dynamicRef",
+  "properties",
+  "patternProperties",
+  "additionalProperties",
+  "unevaluatedProperties",
+  "propertyNames",
+  "items",
+  "prefixItems",
+  "additionalItems",
+  "unevaluatedItems",
+  "contains",
+  "allOf",
+  "if",
+  "then",
+  "else",
+  "dependentSchemas"
+]);
+var jsonSchemaProblems = (errors) => {
+  const problems = errors.flatMap(({ keyword, instanceLocation, error }) => {
+    if (containerKeywords.has(keyword)) return [];
+    const path = instanceLocation.replace(/^#\/?/, "").split("/").filter((segment) => segment !== "").map((segment) => decodeURIComponent(segment).replace(/~1/g, "/").replace(/~0/g, "~")).map((segment) => /^\d+$/.test(segment) ? Number(segment) : segment);
+    const required = keyword === "required" ? /required property "([^"]*)"/.exec(error) : null;
+    const expected = keyword === "type" ? /Expected "([^.]*)"\.?$/.exec(error) : null;
+    const issue = required !== null ? { path: [...path, required[1] ?? ""], issue: "Missing key" } : {
+      path,
+      issue: expected !== null ? `Expected ${(expected[1] ?? "").replace(/"/g, "")}` : keyword === "const" || keyword === "enum" ? "Expected one of the allowed values" : `Failed the "${keyword}" constraint`
+    };
+    return [issue];
+  });
+  return problems.length === 0 ? false : problems;
+};
 var compileJsonSchemaDecoder = (document) => Effect_exports.gen(function* () {
   const validator = yield* Effect_exports.try({
     try: () => {
@@ -1266,7 +1319,8 @@ var compileJsonSchemaDecoder = (document) => Effect_exports.gen(function* () {
     Schema_exports.makeFilter(
       (value) => {
         try {
-          return validator.validate(value).valid;
+          const result = validator.validate(value);
+          return result.valid || jsonSchemaProblems(result.errors);
         } catch {
           return false;
         }
@@ -1276,23 +1330,23 @@ var compileJsonSchemaDecoder = (document) => Effect_exports.gen(function* () {
   );
   return Object.assign(decoder, { [ImportedJsonSchema]: document });
 });
-var jsonSchemaDecoder = (input) => Effect_exports.gen(function* () {
-  const document = yield* parse(
-    Schema_exports.Record(Schema_exports.String, Schema_exports.Json),
-    input
-  );
-  const compiled = yield* Effect_exports.cached(compileJsonSchemaDecoder(document));
+var lazyJsonSchemaDecoder = (document) => Effect_exports.gen(function* () {
+  const read = once(document);
+  const compiled = yield* Effect_exports.cached(Effect_exports.suspend(() => compileJsonSchemaDecoder(read())));
   const decoder = Schema_exports.declareConstructor()(
     [],
-    () => (input2, _ast, options) => compiled.pipe(
+    () => (input, _ast, options) => compiled.pipe(
       Effect_exports.mapError(
         () => new SchemaIssue_exports.InvalidValue({ message: "Unsupported JSON Schema" })
       ),
-      Effect_exports.flatMap((schema) => SchemaParser_exports.decodeUnknownEffect(schema)(input2, options))
+      Effect_exports.flatMap((schema) => SchemaParser_exports.decodeUnknownEffect(schema)(input, options))
     )
   );
-  return Object.assign(decoder, { [ImportedJsonSchema]: document });
+  return withLazyJsonSchemaDocument(decoder, read);
 });
+var jsonSchemaDecoder = (input) => parse(Schema_exports.Record(Schema_exports.String, Schema_exports.Json), input).pipe(
+  Effect_exports.flatMap((document) => lazyJsonSchemaDecoder(() => document))
+);
 var jsonSchema = (input) => wrap(Effect_exports.runSync(jsonSchemaDecoder(input)), false);
 var storageFieldOf = (schema) => schema[StorageField];
 var id = (table) => wrap(Schema_exports.NonEmptyString, false, { kind: "id", references: table });
@@ -1312,9 +1366,11 @@ export {
   array,
   object,
   importedJsonSchema,
-  withJsonSchemaDocument,
+  once,
+  withLazyJsonSchemaDocument,
   nestJsonSchema,
   compileJsonSchemaDecoder,
+  lazyJsonSchemaDecoder,
   jsonSchemaDecoder,
   jsonSchema,
   storageFieldOf,

package/js/{chunk-SBKHUC5L.js → chunk-4LPG6RCH.js}

@@ -5,10 +5,10 @@ import {
   UiFailed,
   UiForbidden,
   UiUnauthorized
-} from "./chunk-3ANFZFCV.js";
+} from "./chunk-OHRT55C4.js";
 import {
   Schema_exports
-} from "./chunk-2OTCEKL2.js";
+} from "./chunk-FW5HBOIK.js";
 
 // src/contracts/ui-auth.ts
 var AppSignInId = Schema_exports.String.check(Schema_exports.isPattern(/^[a-f0-9]{64}$/)).pipe(

package/js/{chunk-LOKGDT6B.js → chunk-6IIO4NPI.js}

@@ -1,6 +1,6 @@
 import {
   operationDeclaration
-} from "./chunk-C24KEZXR.js";
+} from "./chunk-PZ36XMXW.js";
 
 // src/implementation/protocol-operations.ts
 var protocolOperations = (operations, kinds = {}) => {
@@ -14,11 +14,12 @@ var protocolOperations = (operations, kinds = {}) => {
       ...operation.annotations === void 0 ? {} : { annotations: operation.annotations },
       ...operation._meta === void 0 ? {} : { _meta: operation._meta },
       input: operation.input,
-      ...operation.outputSchema === void 0 ? {} : { outputSchema: operation.outputSchema },
       run: operation.run
     };
-    if (kind === "query") queries[name] = operationDeclaration({ ...native, kind });
-    else mutations[name] = operationDeclaration({ ...native, kind: "mutation" });
+    const output = Object.getOwnPropertyDescriptor(operation, "outputSchema");
+    const withOutput = (target) => output === void 0 || output.get === void 0 && output.value === void 0 ? target : Object.defineProperty(target, "outputSchema", { ...output, enumerable: true });
+    if (kind === "query") queries[name] = operationDeclaration(withOutput({ ...native, kind }));
+    else mutations[name] = operationDeclaration(withOutput({ ...native, kind: "mutation" }));
   }
   return { queries, mutations };
 };

package/js/chunk-6YBRWRK3.js

@@ -0,0 +1,160 @@
+import {
+  CacheError
+} from "./chunk-RBAC33PQ.js";
+import {
+  wrap
+} from "./chunk-2HHMABB6.js";
+import {
+  JsonObject
+} from "./chunk-SATWJKN6.js";
+import {
+  Duration_exports,
+  Effect_exports,
+  Schema_exports
+} from "./chunk-FW5HBOIK.js";
+
+// src/implementation/catalog-cache.ts
+var schema = (decoder) => wrap(decoder, false);
+var Manifest = Schema_exports.Struct({
+  revision: Schema_exports.String,
+  pages: Schema_exports.Int,
+  summaries: Schema_exports.Int
+});
+var invoke = (work) => Effect_exports.tryPromise({ try: work, catch: (error) => error });
+var catalogCache = (options) => Effect_exports.gen(function* () {
+  const cache = options.cache;
+  const key = [...options.prefix, "current"];
+  const part = (revision, kind, name) => [
+    ...options.prefix,
+    revision,
+    kind,
+    name
+  ];
+  const freshFor = options.freshFor ?? "5 minutes";
+  const staleFor = options.staleFor ?? "1 day";
+  const retention = Duration_exports.toMillis(Duration_exports.fromInputUnsafe(freshFor)) + Duration_exports.toMillis(Duration_exports.fromInputUnsafe(staleFor)) + 3e5;
+  const local = yield* Effect_exports.cached(options.load());
+  const refresh = (context) => Effect_exports.gen(function* () {
+    const tools = yield* options.load(context);
+    const digest = yield* invoke(
+      () => crypto.subtle.digest("SHA-256", new TextEncoder().encode(JSON.stringify(tools)))
+    );
+    const revision = Array.from(
+      new Uint8Array(digest),
+      (byte) => byte.toString(16).padStart(2, "0")
+    ).join("");
+    let pages2 = 0;
+    let page = [];
+    let pageBytes = 0;
+    let summaries = 0;
+    let summary = [];
+    let summaryBytes = 0;
+    let batch = [];
+    let batchBytes = 0;
+    const flush = () => invoke(async () => {
+      if (batch.length) await context.cache.write(batch, retention);
+      batch = [];
+      batchBytes = 0;
+    });
+    const append = (entry) => Effect_exports.gen(function* () {
+      const bytes = new TextEncoder().encode(JSON.stringify(entry)).byteLength;
+      if (batch.length && (batch.length >= 64 || batchBytes + bytes > 4e6))
+        yield* flush();
+      batch.push(entry);
+      batchBytes += bytes;
+    });
+    const pageOut = () => Effect_exports.gen(function* () {
+      if (!page.length) return;
+      yield* append({ key: part(revision, "page", pages2++), value: page });
+      page = [];
+      pageBytes = 0;
+    });
+    const summaryOut = () => Effect_exports.gen(function* () {
+      if (!summary.length) return;
+      yield* append({ key: part(revision, "summary", summaries++), value: summary });
+      summary = [];
+      summaryBytes = 0;
+    });
+    const json = (value) => Schema_exports.decodeUnknownEffect(Schema_exports.fromJsonString(JsonObject))(JSON.stringify(value));
+    for (const tool of tools) {
+      const value = yield* json(tool);
+      const bytes = new TextEncoder().encode(JSON.stringify(value)).byteLength;
+      if (page.length && (page.length >= 64 || pageBytes + bytes > 5e5)) yield* pageOut();
+      yield* append({ key: part(revision, "tool", tool.name), value });
+      page.push(value);
+      pageBytes += bytes;
+      const brief = yield* json(options.summary.of(tool));
+      const briefBytes = new TextEncoder().encode(JSON.stringify(brief)).byteLength;
+      if (summary.length && summaryBytes + briefBytes > 5e5) yield* summaryOut();
+      summary.push(brief);
+      summaryBytes += briefBytes;
+    }
+    yield* pageOut();
+    yield* summaryOut();
+    yield* flush();
+    return { revision, pages: pages2, summaries };
+  });
+  const getOptions = {
+    key,
+    schema: schema(Manifest),
+    freshFor,
+    staleFor,
+    load: (context) => Effect_exports.runPromise(refresh(context), { signal: context.signal })
+  };
+  const current = () => cache === void 0 ? Effect_exports.fail(new CacheError({ reason: "unavailable" })) : invoke(() => cache.get(getOptions));
+  if (options.revalidate) {
+    if (cache === void 0) yield* local;
+    else yield* invoke(() => cache.revalidate(getOptions));
+  }
+  const pages = (cache2, revision, kind, count, decoder) => Effect_exports.gen(function* () {
+    const batches = yield* Effect_exports.forEach(
+      Array.from({ length: Math.ceil(count / 4) }, (_, batch) => batch * 4),
+      (offset) => invoke(
+        () => cache2.readMany(
+          Array.from(
+            { length: Math.min(4, count - offset) },
+            (_, index) => part(revision, kind, offset + index)
+          ),
+          schema(Schema_exports.Array(decoder))
+        )
+      ),
+      { concurrency: "unbounded" }
+    );
+    const values = [];
+    for (const page of batches.flat()) {
+      if (page === void 0) return yield* new CacheError({ reason: "unavailable" });
+      values.push(...page);
+    }
+    return values;
+  });
+  const metadata = () => Effect_exports.gen(function* () {
+    if (cache === void 0) return yield* local;
+    const manifest = yield* current();
+    return yield* pages(cache, manifest.revision, "page", manifest.pages, options.schema);
+  });
+  return {
+    list: metadata,
+    summaries: () => Effect_exports.gen(function* () {
+      if (cache === void 0) return (yield* local).map((tool) => options.summary.of(tool));
+      const manifest = yield* current();
+      return yield* pages(
+        cache,
+        manifest.revision,
+        "summary",
+        manifest.summaries,
+        options.summary.schema
+      );
+    }),
+    resolve: (name) => cache === void 0 ? local.pipe(Effect_exports.map((tools) => tools.find((tool) => tool.name === name))) : current().pipe(
+      Effect_exports.flatMap(
+        (manifest) => invoke(
+          () => cache.read(part(manifest.revision, "tool", name), schema(options.schema))
+        )
+      )
+    )
+  };
+});
+
+export {
+  catalogCache
+};

package/js/{chunk-7JXHF5IF.js → chunk-BMOIAIVR.js}

@@ -1,6 +1,6 @@
 import {
   Schema_exports
-} from "./chunk-2OTCEKL2.js";
+} from "./chunk-FW5HBOIK.js";
 
 // ../app-data/src/contracts/database.ts
 var DataName = Schema_exports.String.check(

package/js/chunk-CZ7CSFO4.js

@@ -0,0 +1,39 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  try {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  } catch (e) {
+    throw mod = 0, e;
+  }
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+export {
+  __commonJS,
+  __export,
+  __toESM
+};

package/js/{chunk-YDR4CPJA.js → chunk-EVJUVWN2.js}

@@ -3,7 +3,7 @@ import {
   invalidate,
   layer,
   mutation
-} from "./chunk-D6BKYP2L.js";
+} from "./chunk-M6ZRRIBI.js";
 import {
   Boolean,
   Cause,
@@ -158,12 +158,12 @@ import {
   void_2,
   whileLoop,
   zipRight
-} from "./chunk-2OTCEKL2.js";
+} from "./chunk-FW5HBOIK.js";
 import {
   __export
-} from "./chunk-MLKGABMK.js";
+} from "./chunk-CZ7CSFO4.js";
 
-// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b0796b742bddeb797269d/node_modules/effect/dist/unstable/reactivity/AsyncResult.js
+// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b+a654a55b752bdb24/node_modules/effect/dist/unstable/reactivity/AsyncResult.js
 var AsyncResult_exports = {};
 __export(AsyncResult_exports, {
   Schema: () => Schema,
@@ -600,7 +600,7 @@ var Schema = (options) => {
   });
 };
 
-// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b0796b742bddeb797269d/node_modules/effect/dist/unstable/reactivity/AtomRegistry.js
+// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b+a654a55b752bdb24/node_modules/effect/dist/unstable/reactivity/AtomRegistry.js
 var AtomRegistry_exports = {};
 __export(AtomRegistry_exports, {
   AtomRegistry: () => AtomRegistry,
@@ -1340,7 +1340,7 @@ function batchRebuildNode(node) {
   }
 }
 
-// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b0796b742bddeb797269d/node_modules/effect/dist/unstable/reactivity/Atom.js
+// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b+a654a55b752bdb24/node_modules/effect/dist/unstable/reactivity/Atom.js
 var Atom_exports = {};
 __export(Atom_exports, {
   Interrupt: () => Interrupt,
@@ -1400,7 +1400,7 @@ __export(Atom_exports, {
   writable: () => writable
 });
 
-// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b0796b742bddeb797269d/node_modules/effect/dist/unstable/persistence/KeyValueStore.js
+// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b+a654a55b752bdb24/node_modules/effect/dist/unstable/persistence/KeyValueStore.js
 var ErrorTypeId = "~effect/persistence/KeyValueStore/KeyValueStoreError";
 var KeyValueStoreError = class extends (/* @__PURE__ */ TaggedError("KeyValueStoreError")) {
   /**
@@ -1442,7 +1442,7 @@ var toSchemaStore = (self, schema) => {
   };
 };
 
-// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b0796b742bddeb797269d/node_modules/effect/dist/unstable/reactivity/Atom.js
+// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b+a654a55b752bdb24/node_modules/effect/dist/unstable/reactivity/Atom.js
 var TypeId3 = "~effect/reactivity/Atom";
 var isAtom = (u) => hasProperty(u, TypeId3);
 var WritableTypeId = "~effect/reactivity/Atom/Writable";