@worker-protocol/hono 0.1.0

package/dist/buckets.js

@@ -0,0 +1,133 @@
+/**
+ * Bucket boundaries, cut in the time zone a Worker declares.
+ *
+ * MET-20 cuts every boundary in the zone the `metrics` entry declares, MET-7 makes a week the ISO
+ * 8601 one beginning Monday, and MET-13 has each bucket carry an end rather than a duration —
+ * because a day across a daylight-saving transition is 23 or 25 hours and a reader comparing
+ * against its own clock would otherwise need a calendar.
+ *
+ * This is the clearest case in the whole SDK for the package carrying what the specification says.
+ * A Worker author who wrote this themselves would write it in UTC, it would work, and it would be
+ * silently wrong for every consumer in a zone that observes daylight saving — a class of bug that
+ * appears twice a year and is attributed to anything but the metric.
+ */
+const formatters = new Map();
+const formatter = (zone) => {
+    let held = formatters.get(zone);
+    if (held === undefined) {
+        held = new Intl.DateTimeFormat("en-US", {
+            timeZone: zone,
+            year: "numeric",
+            month: "2-digit",
+            day: "2-digit",
+            hour: "2-digit",
+            minute: "2-digit",
+            second: "2-digit",
+            hour12: false,
+        });
+        formatters.set(zone, held);
+    }
+    return held;
+};
+/** The wall clock an instant reads as, in a zone. */
+function wallClock(at, zone) {
+    const read = {};
+    for (const part of formatter(zone).formatToParts(new Date(at))) {
+        if (part.type !== "literal")
+            read[part.type] = part.value;
+    }
+    return {
+        year: Number(read.year),
+        // `hour` reads `24` at midnight under some ICU versions, which is the same instant as `0`.
+        month: Number(read.month),
+        day: Number(read.day),
+        hour: Number(read.hour) % 24,
+        minute: Number(read.minute),
+    };
+}
+/** How far the zone is from UTC at an instant, in milliseconds. */
+const offset = (at, zone) => {
+    const local = wallClock(at, zone);
+    return Date.UTC(local.year, local.month - 1, local.day, local.hour, local.minute) - at;
+};
+/**
+ * The instant a wall clock reads at, in a zone.
+ *
+ * Two passes, because the offset to subtract is the one in force at the answer rather than at the
+ * guess, and the two differ exactly across a transition. An hour that a zone skips has no instant
+ * and this lands on the one after it; an hour a zone repeats has two and this takes the first,
+ * which is the convention every calendar makes and is worth knowing about rather than discovering.
+ */
+function instantOf(parts, zone) {
+    const local = Date.UTC(parts.year, parts.month - 1, parts.day, parts.hour, parts.minute);
+    const first = local - offset(local, zone);
+    return local - offset(first, zone);
+}
+/** MET-20, MET-7 — the start of the bucket an instant falls in. */
+export function startOf(at, granularity, zone) {
+    const local = wallClock(at, zone);
+    const midnight = { ...local, hour: 0, minute: 0 };
+    if (granularity === "hour")
+        return instantOf({ ...local, minute: 0 }, zone);
+    if (granularity === "day")
+        return instantOf(midnight, zone);
+    if (granularity === "month")
+        return instantOf({ ...midnight, day: 1 }, zone);
+    if (granularity === "year")
+        return instantOf({ ...midnight, month: 1, day: 1 }, zone);
+    // MET-7: the ISO 8601 week, beginning Monday. The weekday is read off the local date rather than
+    // off the instant, because the two disagree either side of midnight in most of the world.
+    const weekday = new Date(Date.UTC(local.year, local.month - 1, local.day)).getUTCDay();
+    const back = (weekday + 6) % 7;
+    const monday = new Date(Date.UTC(local.year, local.month - 1, local.day - back));
+    return instantOf({
+        year: monday.getUTCFullYear(),
+        month: monday.getUTCMonth() + 1,
+        day: monday.getUTCDate(),
+        hour: 0,
+        minute: 0,
+    }, zone);
+}
+/** MET-13 — the end of a bucket, which is the start of the next one and is carried, not derived. */
+export function endOf(start, granularity, zone) {
+    const local = wallClock(start, zone);
+    const next = granularity === "hour"
+        ? { ...local, hour: local.hour + 1 }
+        : granularity === "day"
+            ? { ...local, day: local.day + 1 }
+            : granularity === "week"
+                ? { ...local, day: local.day + 7 }
+                : granularity === "month"
+                    ? { ...local, month: local.month + 1 }
+                    : { ...local, year: local.year + 1 };
+    // `Date.UTC` normalises a 32nd of January or a 13th month, so nothing here needs a calendar.
+    return instantOf(next, zone);
+}
+/**
+ * MET-11, MET-12 — the whole buckets a half-open interval covers.
+ *
+ * Whole or not at all: a read starting mid-bucket gets the buckets whose START falls in the
+ * interval, so two adjacent reads share a boundary instant and no bucket is answered twice.
+ */
+export function bucketsIn(from, to, granularity, zone) {
+    const buckets = [];
+    let start = startOf(from, granularity, zone);
+    if (start < from)
+        start = endOf(start, granularity, zone);
+    // A bound rather than a `while (true)`: a zone or a granularity that failed to advance would
+    // otherwise hang a Worker on a request, which is a worse failure than a short answer.
+    for (let n = 0; n < 10_000 && start < to; n++) {
+        const end = endOf(start, granularity, zone);
+        if (end <= start)
+            break;
+        buckets.push({ start, end });
+        start = end;
+    }
+    return buckets;
+}
+/**
+ * An RFC 3339 instant carrying an offset, which is what MET-13, TASK-28, ALRT-3 and ACTV-3 travel
+ * as. It takes whichever of the two a caller already holds, so that reaching it never costs a
+ * `new Date` or a `.getTime()` at the call site.
+ */
+export const rfc3339 = (at) => (at instanceof Date ? at : new Date(at)).toISOString().replace(/\.\d{3}Z$/, "Z");

package/dist/codes.d.ts

@@ -0,0 +1,201 @@
+/**
+ * ENDP-25, ENDP-26 — the closed code vocabulary, with the status each code is answered with.
+ *
+ * `schemas/error.json` carries the code with its class, which is the half a schema can assert. The
+ * status is not in the body, so it lived in a table in `spec/endpoints.md` that
+ * `packages/conformance` parsed with a regular expression. It lives here now, and that table is a
+ * reading aid — which is what makes the surface declaration normative rather than a convenience.
+ *
+ * This file carries data and imports nothing, deliberately: `generate-rules.ts` reads it from
+ * source, and CI runs `rules:check` before any package is built, so an import of
+ * `@worker-protocol/schemas` here would fail on a clean checkout. The class column therefore
+ * restates what `rejectCodes` and `retryCodes` in that package already partition; `error.json`
+ * and the verifier are what keep the two in step.
+ *
+ * `as const` is what makes `ErrorCode` a real union rather than `string`: a typo in a code is then
+ * a compile error, which is the whole return on a closed vocabulary.
+ */
+export declare const CODES: readonly [{
+    readonly code: "malformed_request";
+    readonly status: 400;
+    readonly class: "reject";
+    readonly condition: "A body that will not parse, or a content type that is not `application/json`.";
+}, {
+    readonly code: "schema_mismatch";
+    readonly status: 400;
+    readonly class: "reject";
+    readonly condition: "A body that parses and does not match the schema the surface declared.";
+}, {
+    readonly code: "invalid_parameter";
+    readonly status: 400;
+    readonly class: "reject";
+    readonly condition: "A parameter missing or malformed.";
+}, {
+    readonly code: "unknown_filter";
+    readonly status: 400;
+    readonly class: "reject";
+    readonly condition: "A filter parameter the Worker does not recognize.";
+}, {
+    readonly code: "unsupported_version";
+    readonly status: 400;
+    readonly class: "reject";
+    readonly condition: "A requested Capability version the Worker cannot answer.";
+}, {
+    readonly code: "idempotency_key_required";
+    readonly status: 400;
+    readonly class: "reject";
+    readonly condition: "An Action requires a key and none was sent.";
+}, {
+    readonly code: "unauthenticated";
+    readonly status: 401;
+    readonly class: "reject";
+    readonly condition: "No credential, or one the Worker cannot read.";
+}, {
+    readonly code: "forbidden";
+    readonly status: 403;
+    readonly class: "reject";
+    readonly condition: "The credential is understood and does not carry the right.";
+}, {
+    readonly code: "not_found";
+    readonly status: 404;
+    readonly class: "reject";
+    readonly condition: "No such address, or no such resource.";
+}, {
+    readonly code: "request_timeout";
+    readonly status: 408;
+    readonly class: "retry";
+    readonly condition: "The request did not arrive in time to be answered.";
+}, {
+    readonly code: "conflict";
+    readonly status: 409;
+    readonly class: "reject";
+    readonly condition: "The request conflicts with the current state.";
+}, {
+    readonly code: "idempotency_key_reused";
+    readonly status: 409;
+    readonly class: "reject";
+    readonly condition: "A key reused with a different body.";
+}, {
+    readonly code: "unprocessable_content";
+    readonly status: 422;
+    readonly class: "reject";
+    readonly condition: "Well-formed, schema-valid, and refused on the Worker's own rules.";
+}, {
+    readonly code: "rate_limited";
+    readonly status: 429;
+    readonly class: "retry";
+    readonly condition: "Too many requests. Carries `Retry-After`.";
+}, {
+    readonly code: "internal_error";
+    readonly status: 500;
+    readonly class: "retry";
+    readonly condition: "The Worker failed for its own reasons.";
+}, {
+    readonly code: "upstream_error";
+    readonly status: 502;
+    readonly class: "retry";
+    readonly condition: "Something the Worker depends on answered badly.";
+}, {
+    readonly code: "unavailable";
+    readonly status: 503;
+    readonly class: "retry";
+    readonly condition: "Starting, `unhealthy`, or a dependency down.";
+}, {
+    readonly code: "upstream_timeout";
+    readonly status: 504;
+    readonly class: "retry";
+    readonly condition: "Something the Worker depends on did not answer in time.";
+}];
+export type ErrorCode = (typeof CODES)[number]["code"];
+/** One row by its code: the status it fixes and the class it carries (ENDP-26). */
+export declare const byCode: Map<"conflict" | "forbidden" | "idempotency_key_required" | "idempotency_key_reused" | "internal_error" | "invalid_parameter" | "malformed_request" | "not_found" | "rate_limited" | "request_timeout" | "schema_mismatch" | "unauthenticated" | "unavailable" | "unknown_filter" | "unprocessable_content" | "unsupported_version" | "upstream_error" | "upstream_timeout", {
+    readonly code: "malformed_request";
+    readonly status: 400;
+    readonly class: "reject";
+    readonly condition: "A body that will not parse, or a content type that is not `application/json`.";
+} | {
+    readonly code: "schema_mismatch";
+    readonly status: 400;
+    readonly class: "reject";
+    readonly condition: "A body that parses and does not match the schema the surface declared.";
+} | {
+    readonly code: "invalid_parameter";
+    readonly status: 400;
+    readonly class: "reject";
+    readonly condition: "A parameter missing or malformed.";
+} | {
+    readonly code: "unknown_filter";
+    readonly status: 400;
+    readonly class: "reject";
+    readonly condition: "A filter parameter the Worker does not recognize.";
+} | {
+    readonly code: "unsupported_version";
+    readonly status: 400;
+    readonly class: "reject";
+    readonly condition: "A requested Capability version the Worker cannot answer.";
+} | {
+    readonly code: "idempotency_key_required";
+    readonly status: 400;
+    readonly class: "reject";
+    readonly condition: "An Action requires a key and none was sent.";
+} | {
+    readonly code: "unauthenticated";
+    readonly status: 401;
+    readonly class: "reject";
+    readonly condition: "No credential, or one the Worker cannot read.";
+} | {
+    readonly code: "forbidden";
+    readonly status: 403;
+    readonly class: "reject";
+    readonly condition: "The credential is understood and does not carry the right.";
+} | {
+    readonly code: "not_found";
+    readonly status: 404;
+    readonly class: "reject";
+    readonly condition: "No such address, or no such resource.";
+} | {
+    readonly code: "request_timeout";
+    readonly status: 408;
+    readonly class: "retry";
+    readonly condition: "The request did not arrive in time to be answered.";
+} | {
+    readonly code: "conflict";
+    readonly status: 409;
+    readonly class: "reject";
+    readonly condition: "The request conflicts with the current state.";
+} | {
+    readonly code: "idempotency_key_reused";
+    readonly status: 409;
+    readonly class: "reject";
+    readonly condition: "A key reused with a different body.";
+} | {
+    readonly code: "unprocessable_content";
+    readonly status: 422;
+    readonly class: "reject";
+    readonly condition: "Well-formed, schema-valid, and refused on the Worker's own rules.";
+} | {
+    readonly code: "rate_limited";
+    readonly status: 429;
+    readonly class: "retry";
+    readonly condition: "Too many requests. Carries `Retry-After`.";
+} | {
+    readonly code: "internal_error";
+    readonly status: 500;
+    readonly class: "retry";
+    readonly condition: "The Worker failed for its own reasons.";
+} | {
+    readonly code: "upstream_error";
+    readonly status: 502;
+    readonly class: "retry";
+    readonly condition: "Something the Worker depends on answered badly.";
+} | {
+    readonly code: "unavailable";
+    readonly status: 503;
+    readonly class: "retry";
+    readonly condition: "Starting, `unhealthy`, or a dependency down.";
+} | {
+    readonly code: "upstream_timeout";
+    readonly status: 504;
+    readonly class: "retry";
+    readonly condition: "Something the Worker depends on did not answer in time.";
+}>;

package/dist/codes.js

@@ -0,0 +1,129 @@
+/**
+ * ENDP-25, ENDP-26 — the closed code vocabulary, with the status each code is answered with.
+ *
+ * `schemas/error.json` carries the code with its class, which is the half a schema can assert. The
+ * status is not in the body, so it lived in a table in `spec/endpoints.md` that
+ * `packages/conformance` parsed with a regular expression. It lives here now, and that table is a
+ * reading aid — which is what makes the surface declaration normative rather than a convenience.
+ *
+ * This file carries data and imports nothing, deliberately: `generate-rules.ts` reads it from
+ * source, and CI runs `rules:check` before any package is built, so an import of
+ * `@worker-protocol/schemas` here would fail on a clean checkout. The class column therefore
+ * restates what `rejectCodes` and `retryCodes` in that package already partition; `error.json`
+ * and the verifier are what keep the two in step.
+ *
+ * `as const` is what makes `ErrorCode` a real union rather than `string`: a typo in a code is then
+ * a compile error, which is the whole return on a closed vocabulary.
+ */
+export const CODES = [
+    {
+        code: "malformed_request",
+        status: 400,
+        class: "reject",
+        condition: "A body that will not parse, or a content type that is not `application/json`.",
+    },
+    {
+        code: "schema_mismatch",
+        status: 400,
+        class: "reject",
+        condition: "A body that parses and does not match the schema the surface declared.",
+    },
+    {
+        code: "invalid_parameter",
+        status: 400,
+        class: "reject",
+        condition: "A parameter missing or malformed.",
+    },
+    {
+        code: "unknown_filter",
+        status: 400,
+        class: "reject",
+        condition: "A filter parameter the Worker does not recognize.",
+    },
+    {
+        code: "unsupported_version",
+        status: 400,
+        class: "reject",
+        condition: "A requested Capability version the Worker cannot answer.",
+    },
+    {
+        code: "idempotency_key_required",
+        status: 400,
+        class: "reject",
+        condition: "An Action requires a key and none was sent.",
+    },
+    {
+        code: "unauthenticated",
+        status: 401,
+        class: "reject",
+        condition: "No credential, or one the Worker cannot read.",
+    },
+    {
+        code: "forbidden",
+        status: 403,
+        class: "reject",
+        condition: "The credential is understood and does not carry the right.",
+    },
+    {
+        code: "not_found",
+        status: 404,
+        class: "reject",
+        condition: "No such address, or no such resource.",
+    },
+    {
+        code: "request_timeout",
+        status: 408,
+        class: "retry",
+        condition: "The request did not arrive in time to be answered.",
+    },
+    {
+        code: "conflict",
+        status: 409,
+        class: "reject",
+        condition: "The request conflicts with the current state.",
+    },
+    {
+        code: "idempotency_key_reused",
+        status: 409,
+        class: "reject",
+        condition: "A key reused with a different body.",
+    },
+    {
+        code: "unprocessable_content",
+        status: 422,
+        class: "reject",
+        condition: "Well-formed, schema-valid, and refused on the Worker's own rules.",
+    },
+    {
+        code: "rate_limited",
+        status: 429,
+        class: "retry",
+        condition: "Too many requests. Carries `Retry-After`.",
+    },
+    {
+        code: "internal_error",
+        status: 500,
+        class: "retry",
+        condition: "The Worker failed for its own reasons.",
+    },
+    {
+        code: "upstream_error",
+        status: 502,
+        class: "retry",
+        condition: "Something the Worker depends on answered badly.",
+    },
+    {
+        code: "unavailable",
+        status: 503,
+        class: "retry",
+        condition: "Starting, `unhealthy`, or a dependency down.",
+    },
+    {
+        code: "upstream_timeout",
+        status: 504,
+        class: "retry",
+        condition: "Something the Worker depends on did not answer in time.",
+    },
+];
+/** One row by its code: the status it fixes and the class it carries (ENDP-26). */
+export const byCode = new Map(CODES.map((c) => [c.code, c]));

package/dist/collection.d.ts

@@ -0,0 +1,44 @@
+/**
+ * The page envelope every collection surface answers in, in one place.
+ *
+ * ENDP-19's cap, ENDP-20's envelope and its absent cursor, ENDP-21's opaque cursor and ENDP-23's
+ * order are the protocol's, not a Worker's, and they were written out three times: once inside
+ * `tasks.ts`, and once inline per handler for `alerts` and `activity` — which carried neither the
+ * cursor nor the cap, while `openapi/` published a `cursor` parameter both of them refused with
+ * `unknown_filter`. A document that describes a call the Worker will not take is the fault this
+ * repository names everywhere else, and one implementation is what stops it recurring.
+ *
+ * What a surface still owns is what it filters on and what its items look like. This carries the
+ * rest.
+ */
+import type { Refusal } from "./worker.ts";
+/** One page: the items as they travel, and ENDP-20's cursor where there is more. */
+export type Page = {
+    items: Record<string, unknown>[];
+    nextCursor?: string;
+};
+/** ENDP-19 (recommended). A Worker caps rather than negotiating; this is the cap when none is set. */
+export declare const DEFAULT_PAGE_SIZE = 50;
+/**
+ * One page of a collection, ordered, cut and serialized.
+ *
+ * The cursor is an offset spelled as a string, which satisfies ENDP-21 without pretending to more:
+ * it is produced only here, a caller sends back what it was given, and anything else is refused as
+ * a parameter this Worker did not mint. ENDP-23's order is by `id` — minted by the Worker and the
+ * one field every collection here has that nothing else reorders — so paging terminates.
+ */
+export declare function collection<T extends {
+    id: string;
+    since: Date;
+}>(items: T[], query: URLSearchParams, serialize: (one: T) => Record<string, unknown>, pageSize?: number, 
+/** What this surface defines beyond the cursor — TASK-8's `type` is the only one today. */
+filters?: readonly string[]): Refusal | Page;
+/**
+ * The instant every item in this protocol carries, serialized once.
+ *
+ * TASK-28, ALRT-3 and ACTV-3 all fix an RFC 3339 instant with an offset, and a Worker hands each
+ * of them a `Date` — so no Worker writes the format and no surface here writes it twice.
+ */
+export declare const serializeSince: <T extends {
+    since: Date;
+}>(one: T) => Record<string, unknown>;

package/dist/collection.js

@@ -0,0 +1,62 @@
+/**
+ * The page envelope every collection surface answers in, in one place.
+ *
+ * ENDP-19's cap, ENDP-20's envelope and its absent cursor, ENDP-21's opaque cursor and ENDP-23's
+ * order are the protocol's, not a Worker's, and they were written out three times: once inside
+ * `tasks.ts`, and once inline per handler for `alerts` and `activity` — which carried neither the
+ * cursor nor the cap, while `openapi/` published a `cursor` parameter both of them refused with
+ * `unknown_filter`. A document that describes a call the Worker will not take is the fault this
+ * repository names everywhere else, and one implementation is what stops it recurring.
+ *
+ * What a surface still owns is what it filters on and what its items look like. This carries the
+ * rest.
+ */
+import { rfc3339 } from "./buckets.js";
+const refuse = (code, message) => ({ code, message });
+/** ENDP-19 (recommended). A Worker caps rather than negotiating; this is the cap when none is set. */
+export const DEFAULT_PAGE_SIZE = 50;
+/**
+ * One page of a collection, ordered, cut and serialized.
+ *
+ * The cursor is an offset spelled as a string, which satisfies ENDP-21 without pretending to more:
+ * it is produced only here, a caller sends back what it was given, and anything else is refused as
+ * a parameter this Worker did not mint. ENDP-23's order is by `id` — minted by the Worker and the
+ * one field every collection here has that nothing else reorders — so paging terminates.
+ */
+export function collection(items, query, serialize, pageSize = DEFAULT_PAGE_SIZE, 
+/** What this surface defines beyond the cursor — TASK-8's `type` is the only one today. */
+filters = []) {
+    // ENDP-24: an unrecognized filter is `400` and is never ignored. A filter dropped in silence
+    // answers with MORE than the caller asked for, in a shape it will happily parse. It is checked
+    // here rather than by a middleware because a surface that reads a cursor has to opt out of the
+    // one that refuses every parameter, and opting out must not mean opting out of this.
+    const defined = new Set(["cursor", ...filters]);
+    for (const key of query.keys()) {
+        if (!defined.has(key)) {
+            return refuse("unknown_filter", `This address takes no parameter named ${key}.`);
+        }
+    }
+    const from = Number(query.get("cursor") ?? "0");
+    if (!Number.isInteger(from) || from < 0) {
+        return refuse("invalid_parameter", "That cursor was not produced by this Worker.");
+    }
+    // Mapped before sorted, so the copy the ordering needs is the one the serialization already made
+    // — `sort` mutates, and the array handed in is the Worker's own.
+    const ordered = items
+        .map((one) => ({ id: one.id, row: serialize(one) }))
+        .sort((a, b) => a.id.localeCompare(b.id));
+    const next = from + pageSize;
+    const page = ordered.slice(from, next).map((one) => one.row);
+    // ENDP-20: the cursor is absent at the end of the collection — absent, not null.
+    return next < ordered.length ? { items: page, nextCursor: String(next) } : { items: page };
+}
+/**
+ * The instant every item in this protocol carries, serialized once.
+ *
+ * TASK-28, ALRT-3 and ACTV-3 all fix an RFC 3339 instant with an offset, and a Worker hands each
+ * of them a `Date` — so no Worker writes the format and no surface here writes it twice.
+ */
+export const serializeSince = (one) => ({
+    ...one,
+    since: rfc3339(one.since),
+});

package/dist/index.d.ts

@@ -0,0 +1,26 @@
+/**
+ * `@worker-protocol/hono` — the protocol's surface as Hono routes, and `mount()`.
+ *
+ * Two things, and the second exists because of the first. The routes in `surfaces.ts` are the
+ * declaration `openapi/` is generated from, and they are `createRoute` objects rather than data of
+ * this repository's own because most Workers built on this protocol run on Hono: the declaration
+ * that runs is the one that generates, and nothing is declared twice. `mount()` is what makes them
+ * run — a Worker author implements `Worker` and gets every address, header, envelope, refusal,
+ * page and bucket boundary this protocol fixes, once, the same way in every Worker.
+ *
+ * This package carries behaviour, and `packages/README.md` says what standing that has: what is
+ * forbidden is behaviour of its OWN — something `spec/` does not say — and what is wanted is all of
+ * what `spec/` does say, because the alternative is every Worker deriving the same rules again.
+ * Every line here cites the rule it carries. `conformance/reference-worker` is `mount()` over an
+ * implementation arranged to be checked, and `@worker-protocol/conformance` passing against it is
+ * what vouches for this package; `examples/minimal-worker` is what says it is cheap.
+ */
+export type { Action, ActionCall, ActionDeclarations, ActionFacts, OutcomeStore, Recorded, Reservation, } from "./actions.ts";
+export { action, jsonSchema, memoryOutcomes } from "./actions.ts";
+export { bucketsIn, endOf, type Granularity, rfc3339, startOf } from "./buckets.ts";
+export { CODES, type ErrorCode } from "./codes.ts";
+export type { Bucket, MetricFacts, MetricQuery, MetricSample } from "./metrics.ts";
+export { defineWorker, type ExecutionCtx, mount, type WorkerBuilder, type WorkerSource, } from "./mount.ts";
+export { performAction, pollHealth, readActivity, readAlerts, readDescriptor, readMetric, readTasks, } from "./surfaces.ts";
+export type { OpenTask, TaskFacts, TaskTypes } from "./tasks.ts";
+export type { Activity, Alert, Answer, Refusal, SkillDeclaration, Worker } from "./worker.ts";

package/dist/index.js

@@ -0,0 +1,22 @@
+/**
+ * `@worker-protocol/hono` — the protocol's surface as Hono routes, and `mount()`.
+ *
+ * Two things, and the second exists because of the first. The routes in `surfaces.ts` are the
+ * declaration `openapi/` is generated from, and they are `createRoute` objects rather than data of
+ * this repository's own because most Workers built on this protocol run on Hono: the declaration
+ * that runs is the one that generates, and nothing is declared twice. `mount()` is what makes them
+ * run — a Worker author implements `Worker` and gets every address, header, envelope, refusal,
+ * page and bucket boundary this protocol fixes, once, the same way in every Worker.
+ *
+ * This package carries behaviour, and `packages/README.md` says what standing that has: what is
+ * forbidden is behaviour of its OWN — something `spec/` does not say — and what is wanted is all of
+ * what `spec/` does say, because the alternative is every Worker deriving the same rules again.
+ * Every line here cites the rule it carries. `conformance/reference-worker` is `mount()` over an
+ * implementation arranged to be checked, and `@worker-protocol/conformance` passing against it is
+ * what vouches for this package; `examples/minimal-worker` is what says it is cheap.
+ */
+export { action, jsonSchema, memoryOutcomes } from "./actions.js";
+export { bucketsIn, endOf, rfc3339, startOf } from "./buckets.js";
+export { CODES } from "./codes.js";
+export { defineWorker, mount, } from "./mount.js";
+export { performAction, pollHealth, readActivity, readAlerts, readDescriptor, readMetric, readTasks, } from "./surfaces.js";