apps 0.0.1-beta.0 → 0.0.1-beta.10

package/js/browser-XIPJGLH2.js

@@ -0,0 +1,65 @@
+import {
+  Alias,
+  Composer,
+  Document,
+  Lexer,
+  LineCounter,
+  Pair,
+  Parser,
+  Scalar,
+  Schema,
+  YAMLError,
+  YAMLMap,
+  YAMLParseError,
+  YAMLSeq,
+  YAMLWarning,
+  browser_default,
+  cst_exports,
+  isAlias,
+  isCollection,
+  isDocument,
+  isMap,
+  isNode,
+  isPair,
+  isScalar,
+  isSeq,
+  parse,
+  parseAllDocuments,
+  parseDocument,
+  stringify,
+  visit,
+  visitAsync
+} from "./chunk-UVL56Z6E.js";
+import "./chunk-CZ7CSFO4.js";
+export {
+  Alias,
+  cst_exports as CST,
+  Composer,
+  Document,
+  Lexer,
+  LineCounter,
+  Pair,
+  Parser,
+  Scalar,
+  Schema,
+  YAMLError,
+  YAMLMap,
+  YAMLParseError,
+  YAMLSeq,
+  YAMLWarning,
+  browser_default as default,
+  isAlias,
+  isCollection,
+  isDocument,
+  isMap,
+  isNode,
+  isPair,
+  isScalar,
+  isSeq,
+  parse,
+  parseAllDocuments,
+  parseDocument,
+  stringify,
+  visit,
+  visitAsync
+};

package/js/{chunk-36DNRFZQ.js → chunk-27F7W2LG.js}

@@ -1,6 +1,6 @@
 import {
   Schema_exports
-} from "./chunk-2OTCEKL2.js";
+} from "./chunk-CDL5PM2Q.js";
 
 // src/contracts/schema.ts
 var JsonValue = Schema_exports.Json;

package/js/{chunk-VFUZI3NY.js → chunk-57RKNWL2.js}

@@ -4,7 +4,7 @@ import {
   fromWeb,
   layerMergedContext,
   make2 as make
-} from "./chunk-W7Q5EOTS.js";
+} from "./chunk-UK573G7W.js";
 import {
   Reference,
   Service,
@@ -17,12 +17,12 @@ import {
   succeed4 as succeed,
   toReadableStreamEffect,
   tryPromise
-} from "./chunk-2OTCEKL2.js";
+} from "./chunk-CDL5PM2Q.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/http/FetchHttpClient.js
+// ../../node_modules/.bun/effect@https+++pkg.pr.new+Effect-TS+effect+effect@c7d1ffff31a3e2ae0b0b+a654a55b752bdb24/node_modules/effect/dist/unstable/http/FetchHttpClient.js
 var FetchHttpClient_exports = {};
 __export(FetchHttpClient_exports, {
   Fetch: () => Fetch,

package/js/{chunk-BPEFS4YF.js → chunk-5T57N25Q.js}

@@ -1,12 +1,16 @@
 import {
+  JsonObject,
   ValidationError
-} from "./chunk-36DNRFZQ.js";
+} from "./chunk-27F7W2LG.js";
 import {
+  Cause_exports,
   Effect_exports,
+  Exit_exports,
+  SchemaGetter_exports,
   SchemaIssue_exports,
   SchemaParser_exports,
   Schema_exports
-} from "./chunk-2OTCEKL2.js";
+} from "./chunk-CDL5PM2Q.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 +1133,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 +1254,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 +1322,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,27 +1333,71 @@ 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
+var lazyDecoder = (document) => {
+  const read = once(document);
+  let compiled;
+  const compile = Effect_exports.suspend(
+    () => compiled ?? compileJsonSchemaDecoder(read()).pipe(
+      // An interrupted compilation is not a result; the next decode compiles again.
+      Effect_exports.onExit(
+        (exit) => Effect_exports.sync(() => {
+          if (Exit_exports.isSuccess(exit) || !Cause_exports.hasInterrupts(exit.cause)) compiled = exit;
+        })
+      )
+    )
   );
-  const compiled = yield* Effect_exports.cached(compileJsonSchemaDecoder(document));
   const decoder = Schema_exports.declareConstructor()(
     [],
-    () => (input2, _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))
+    () => (input, _ast, options) => compile.pipe(
+      Effect_exports.mapError(() => new SchemaIssue_exports.InvalidValue({ message: "Unsupported JSON Schema" })),
+      Effect_exports.flatMap((schema) => SchemaParser_exports.decodeUnknownEffect(schema)(input, options))
     )
   );
-  return Object.assign(decoder, { [ImportedJsonSchema]: document });
+  return withLazyJsonSchemaDocument(decoder, read);
+};
+var lazyJsonSchemaDecoder = (document) => Effect_exports.sync(() => lazyDecoder(document));
+var isJsonValue = Schema_exports.is(Schema_exports.Json);
+var jsonDocument = (input) => {
+  if (typeof input !== "object" || input === null || Array.isArray(input)) return void 0;
+  const keys = Object.keys(input);
+  const values = keys.map((key) => Reflect.get(input, key));
+  if (!isJsonValue(values)) return void 0;
+  const document = {};
+  keys.forEach(
+    (key, index) => Object.defineProperty(document, key, {
+      value: values[index],
+      enumerable: true,
+      writable: true,
+      configurable: true
+    })
+  );
+  return document;
+};
+var jsonSchemaDecoder = (input) => Effect_exports.suspend(() => {
+  const document = jsonDocument(input);
+  return document === void 0 ? Effect_exports.fail(new ValidationError()) : lazyJsonSchemaDecoder(() => document);
 });
-var jsonSchema = (input) => wrap(Effect_exports.runSync(jsonSchemaDecoder(input)), false);
+var jsonSchema = (input) => {
+  const document = jsonDocument(input);
+  if (document === void 0) throw new ValidationError();
+  return wrap(
+    lazyDecoder(() => document),
+    false
+  );
+};
 var storageFieldOf = (schema) => schema[StorageField];
 var id = (table) => wrap(Schema_exports.NonEmptyString, false, { kind: "id", references: table });
 var userId = () => wrap(Schema_exports.NonEmptyString, false, { kind: "userId" });
+var jsonSchemaDocument = (decoder) => {
+  const imported = importedJsonSchema(decoder);
+  if (imported !== void 0) return Schema_exports.decodeUnknownEffect(JsonObject)(imported);
+  const document = Schema_exports.toJsonSchemaDocument(decoder);
+  return Schema_exports.decodeUnknownEffect(JsonObject)({
+    ...document.schema,
+    $defs: document.definitions,
+    $schema: "https://json-schema.org/draft/2020-12/schema"
+  });
+};
 
 export {
   decoderOf,
@@ -1312,12 +1413,15 @@ export {
   array,
   object,
   importedJsonSchema,
-  withJsonSchemaDocument,
+  once,
+  withLazyJsonSchemaDocument,
   nestJsonSchema,
   compileJsonSchemaDecoder,
+  lazyJsonSchemaDecoder,
   jsonSchemaDecoder,
   jsonSchema,
   storageFieldOf,
   id,
-  userId
+  userId,
+  jsonSchemaDocument
 };

package/js/chunk-72JNVHPK.js

@@ -0,0 +1,41 @@
+import {
+  fixedRouter
+} from "./chunk-FL2QR3XW.js";
+import {
+  nativeOperation,
+  operationDeclaration,
+  routerDeclaration
+} from "./chunk-Z5M2LQOZ.js";
+
+// src/implementation/protocol-operations.ts
+var protocolOperations = (operations, kinds = {}) => {
+  const declared = {};
+  for (const [name, operation] of Object.entries(operations)) {
+    const kind = Object.hasOwn(kinds, name) ? kinds[name] ?? "mutation" : operation.readOnly === true ? "query" : "mutation";
+    const native = {
+      description: operation.description,
+      ...operation.title === void 0 ? {} : { title: operation.title },
+      ...operation.annotations === void 0 ? {} : { annotations: operation.annotations },
+      ...operation._meta === void 0 ? {} : { _meta: operation._meta },
+      input: operation.input,
+      run: operation.run
+    };
+    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 });
+    declared[name] = operationDeclaration(withOutput({ ...native, kind }));
+  }
+  return declared;
+};
+var protocolRouter = (operations, kinds = {}) => {
+  const native = {};
+  for (const [name, declaration] of Object.entries(protocolOperations(operations, kinds))) {
+    const operation = nativeOperation(declaration);
+    if (operation !== void 0) native[name] = operation;
+  }
+  return routerDeclaration(fixedRouter(native));
+};
+
+export {
+  protocolOperations,
+  protocolRouter
+};