@alchemy.run/pkg 0.0.0-placeholder → 2.0.0-beta.78

package/dist/Registry/Tags.js

@@ -0,0 +1,80 @@
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+import * as SqlClient from "effect/unstable/sql/SqlClient";
+/**
+ * The `tags` table: one row per `(package, tag)` pointing at a tarball hash.
+ * A tarball lives in R2 for as long as any row points at it. Every query
+ * runs against the ambient `SqlClient`, which the Worker provides from its
+ * D1 binding.
+ */
+const LinkedPrs = Schema.fromJsonString(Schema.Array(Schema.String));
+export const TagRow = Schema.Struct({
+    package: Schema.String,
+    tag: Schema.String,
+    sha256: Schema.String,
+    expires_at: Schema.Number,
+    /** Pull requests whose runs produced this tag, as `owner/repo#N`. */
+    linked_prs: LinkedPrs,
+});
+const TarballRow = Schema.Struct({
+    package: Schema.String,
+    sha256: Schema.String,
+});
+const decodeTags = Schema.decodeUnknownEffect(Schema.Array(TagRow));
+const decodeTarballs = Schema.decodeUnknownEffect(Schema.Array(TarballRow));
+export const get = Effect.fn("Tags.get")(function* (pkg, tag) {
+    const sql = yield* SqlClient.SqlClient;
+    const rows = yield* decodeTags(yield* sql `SELECT * FROM tags WHERE package = ${pkg} AND tag = ${tag}`);
+    return rows[0];
+});
+/**
+ * Point `tag` at `sha256`, keeping the row alive for at least `expiresAt`
+ * and remembering every pull request that produced it. One statement, so
+ * concurrent publications of a shared tag merge rather than overwrite.
+ */
+export const upsert = Effect.fn("Tags.upsert")(function* (input) {
+    const sql = yield* SqlClient.SqlClient;
+    const prs = yield* Schema.encodeEffect(LinkedPrs)(input.prs);
+    yield* sql `
+    INSERT INTO tags (package, tag, sha256, expires_at, linked_prs)
+    VALUES (${input.package}, ${input.tag}, ${input.sha256}, ${input.expiresAt}, ${prs})
+    ON CONFLICT (package, tag) DO UPDATE SET
+      sha256 = excluded.sha256,
+      expires_at = max(tags.expires_at, excluded.expires_at),
+      linked_prs = (
+        SELECT json_group_array(value) FROM (
+          SELECT value FROM json_each(tags.linked_prs)
+          UNION
+          SELECT value FROM json_each(excluded.linked_prs)
+        )
+      )
+  `;
+});
+export const resolve = (pkg, tag) => Effect.map(get(pkg, tag), (row) => row?.sha256);
+/** Rows tied to pull requests whose expiry falls before `before`. */
+export const dueLinked = Effect.fn("Tags.dueLinked")(function* (before) {
+    const sql = yield* SqlClient.SqlClient;
+    return yield* decodeTags(yield* sql `
+      SELECT * FROM tags WHERE linked_prs != '[]' AND expires_at < ${before}
+    `);
+});
+export const setExpiry = Effect.fn("Tags.setExpiry")(function* (pkg, tag, expiresAt) {
+    const sql = yield* SqlClient.SqlClient;
+    yield* sql `
+    UPDATE tags SET expires_at = ${expiresAt} WHERE package = ${pkg} AND tag = ${tag}
+  `;
+});
+/** Delete every expired row and return the tarballs those rows pointed at. */
+export const deleteExpired = Effect.fn("Tags.deleteExpired")(function* (now) {
+    const sql = yield* SqlClient.SqlClient;
+    return yield* decodeTarballs(yield* sql `
+      DELETE FROM tags WHERE expires_at < ${now} RETURNING package, sha256
+    `);
+});
+/** Every tarball some tag still points at, as `<package>/<sha256>`. */
+export const referencedTarballs = Effect.fn("Tags.referencedTarballs")(function* () {
+    const sql = yield* SqlClient.SqlClient;
+    const rows = yield* decodeTarballs(yield* sql `SELECT DISTINCT package, sha256 FROM tags`);
+    return new Set(rows.map((row) => `${row.package}/${row.sha256}`));
+});
+//# sourceMappingURL=Tags.js.map

package/dist/Registry/Tags.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Tags.js","sourceRoot":"","sources":["../../src/Registry/Tags.ts"],"names":[],"mappings":"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"}

package/dist/Registry.d.ts

@@ -0,0 +1,378 @@
+import * as Cloudflare from "alchemy/Cloudflare";
+import type * as ByteSize from "effect/ByteSize";
+import * as Config from "effect/Config";
+import type * as Duration from "effect/Duration";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import { type GitHubCredentials, type WorkerOverrides } from "./Registry/Bindings.ts";
+export { Bucket, Cache, Database, Policy, RegistryConfig, Settings, } from "./Registry/Bindings.ts";
+export interface RegistryOptions {
+    /**
+     * Worker props forwarded verbatim: `domain`, `name`, `compatibility`,
+     * `observability`, `access`, and so on. `main`, `env`, and `crons` are
+     * owned by the registry.
+     */
+    readonly worker?: WorkerOverrides;
+    /** GitHub App credentials, read at deploy time and bound to the Worker. */
+    readonly github: GitHubCredentials & {
+        /** @default "https://api.github.com" */
+        readonly apiUrl?: string;
+    };
+    readonly policy: {
+        /** Repositories allowed to publish, as `owner/name`. */
+        readonly repos: ReadonlyArray<string>;
+        /** @default Duration.weeks(1) */
+        readonly ttl?: Duration.Duration;
+        /** Upper bound on a single tarball. Absent means unlimited. */
+        readonly maxPackageSize?: ByteSize.ByteSize;
+    };
+    /**
+     * Hostname to package scope. Requests on an aliased host resolve an
+     * unscoped name under that scope, so `pkg.distilled.cloud/core/<sha>`
+     * serves `@distilled.cloud/core`.
+     */
+    readonly aliases?: Readonly<Record<string, string>>;
+    /**
+     * Cron expression for the expiry sweep.
+     * @default "0 * * * *"
+     */
+    readonly cron?: string;
+}
+declare const Registry_base: Effect.Effect<import("effect/Pipeable").Pipeable & import("alchemy").ResourceLike<"Cloudflare.Worker", Cloudflare.WorkerProps<any, Cloudflare.WorkerAssetsConfig | undefined>, {
+    workerId: string;
+    workerName: string;
+    namespace: string | undefined;
+    logpush: boolean | undefined;
+    url: string | undefined;
+    urls: string[];
+    domain: {
+        name: string;
+        aliases: string[];
+        redirects: string[];
+        zone?: Cloudflare.Zone.Reference;
+        previews?: boolean;
+    } | undefined;
+    tags: string[] | undefined;
+    durableObjectNamespaces: Record<string, string>;
+    accountId: string;
+    routes: {
+        id: string;
+        pattern: string;
+        zoneId: string;
+    }[];
+    crons: string[];
+    tailConsumers?: {
+        service: string;
+    }[] | undefined;
+    streamingTailConsumers?: {
+        service: string;
+    }[] | undefined;
+    versionOf?: string | undefined;
+    previewOf?: string | undefined;
+    previewId?: string | undefined;
+    previewName?: string | undefined;
+    previewSlug?: string | undefined;
+    previewDoClasses?: string[] | undefined;
+    versionId?: string | undefined;
+    versionAlias?: string | undefined;
+    deploymentId?: string | undefined;
+    affinityZoneIds?: string[] | undefined;
+    hash?: {
+        assets: string | undefined;
+        bundle: string | undefined;
+        input: string | undefined;
+        additionalWorkspaces: string[] | undefined;
+        metadata?: string | undefined;
+    };
+}, {
+    bindings?: Cloudflare.WorkerBinding[];
+    env?: Record<string, any>;
+    cache?: Cloudflare.WorkerCache;
+    observability?: Pick<Cloudflare.WorkerObservability, "traces">;
+    containers?: {
+        className: string;
+        dev: Cloudflare.DevContainerImage | undefined;
+        hash: string | undefined;
+    }[];
+    crons?: string[];
+    hyperdrives?: Record<string, Required<Cloudflare.Hyperdrive.DevOrigin>>;
+    devRemote?: Record<string, boolean>;
+}, Cloudflare.Providers> & {
+    bind(sid: import("alchemy").Input<string>, binding: import("alchemy").Input<{
+        bindings?: Cloudflare.WorkerBinding[];
+        env?: Record<string, any>;
+        cache?: Cloudflare.WorkerCache;
+        observability?: Pick<Cloudflare.WorkerObservability, "traces">;
+        containers?: {
+            className: string;
+            dev: Cloudflare.DevContainerImage | undefined;
+            hash: string | undefined;
+        }[];
+        crons?: string[];
+        hyperdrives?: Record<string, Required<Cloudflare.Hyperdrive.DevOrigin>>;
+        devRemote?: Record<string, boolean>;
+    }>): Effect.Effect<void>;
+    bind(template: TemplateStringsArray, ...args: any[]): (binding: import("alchemy").Input<{
+        bindings?: Cloudflare.WorkerBinding[];
+        env?: Record<string, any>;
+        cache?: Cloudflare.WorkerCache;
+        observability?: Pick<Cloudflare.WorkerObservability, "traces">;
+        containers?: {
+            className: string;
+            dev: Cloudflare.DevContainerImage | undefined;
+            hash: string | undefined;
+        }[];
+        crons?: string[];
+        hyperdrives?: Record<string, Required<Cloudflare.Hyperdrive.DevOrigin>>;
+        devRemote?: Record<string, boolean>;
+    }>) => Effect.Effect<void>;
+} & {
+    workerId: import("alchemy").Output<string, never>;
+    workerName: import("alchemy").Output<string, never>;
+    namespace: import("alchemy").Output<string | undefined, never>;
+    logpush: import("alchemy").Output<boolean | undefined, never>;
+    url: import("alchemy").Output<string | undefined, never>;
+    urls: import("alchemy").Output<string[], never>;
+    domain: import("alchemy").Output<{
+        name: string;
+        aliases: string[];
+        redirects: string[];
+        zone?: Cloudflare.Zone.Reference;
+        previews?: boolean;
+    } | undefined, never>;
+    tags: import("alchemy").Output<string[] | undefined, never>;
+    durableObjectNamespaces: import("alchemy/Output").ObjectExpr<Record<string, string>, never>;
+    accountId: import("alchemy").Output<string, never>;
+    routes: import("alchemy").Output<{
+        id: string;
+        pattern: string;
+        zoneId: string;
+    }[], never>;
+    crons: import("alchemy").Output<string[], never>;
+    tailConsumers: import("alchemy").Output<{
+        service: string;
+    }[] | undefined, never>;
+    streamingTailConsumers: import("alchemy").Output<{
+        service: string;
+    }[] | undefined, never>;
+    versionOf: import("alchemy").Output<string | undefined, never>;
+    previewOf: import("alchemy").Output<string | undefined, never>;
+    previewId: import("alchemy").Output<string | undefined, never>;
+    previewName: import("alchemy").Output<string | undefined, never>;
+    previewSlug: import("alchemy").Output<string | undefined, never>;
+    previewDoClasses: import("alchemy").Output<string[] | undefined, never>;
+    versionId: import("alchemy").Output<string | undefined, never>;
+    versionAlias: import("alchemy").Output<string | undefined, never>;
+    deploymentId: import("alchemy").Output<string | undefined, never>;
+    affinityZoneIds: import("alchemy").Output<string[] | undefined, never>;
+    hash: import("alchemy").Output<{
+        assets: string | undefined;
+        bundle: string | undefined;
+        input: string | undefined;
+        additionalWorkspaces: string[] | undefined;
+        metadata?: string | undefined;
+    } | undefined, never>;
+} & Cloudflare.Rpc<Registry> & import("alchemy").Dependencies<never>, never, Cloudflare.Providers | Registry> & import("alchemy").Named<"Worker"> & {
+    new (_: never): {
+        fetch?: Effect.Effect<import("alchemy/Http").HttpEffect<import("alchemy").RuntimeContext | import("alchemy").PlatformServices | Cloudflare.WorkerServices>, never, import("alchemy").PlatformServices | Cloudflare.WorkerServices> | import("alchemy/Http").HttpEffect<import("alchemy").RuntimeContext | import("alchemy").PlatformServices | Cloudflare.WorkerServices> | undefined;
+    } & import("alchemy").MainRpc<Cloudflare.WorkerServices> & import("alchemy").Named<"Worker"> & import("alchemy/Named").Tag<"Cloudflare.Worker">;
+    of(shape: {} & Cloudflare.WorkerShape<never>): {
+        fetch?: Effect.Effect<import("alchemy/Http").HttpEffect<import("alchemy").RuntimeContext | import("alchemy").PlatformServices | Cloudflare.WorkerServices>, never, import("alchemy").PlatformServices | Cloudflare.WorkerServices> | import("alchemy/Http").HttpEffect<import("alchemy").RuntimeContext | import("alchemy").PlatformServices | Cloudflare.WorkerServices> | undefined;
+    } & import("alchemy").MainRpc<Cloudflare.WorkerServices>;
+    make<PropsReq = never, InitReq = never>(props: Effect.Effect<import("alchemy").InputProps<Cloudflare.WorkerProps<any, Cloudflare.WorkerAssetsConfig | undefined>, never>, Config.ConfigError, PropsReq> | import("alchemy").InputProps<Cloudflare.WorkerProps<any, Cloudflare.WorkerAssetsConfig | undefined>, never>, impl: Effect.Effect<{}, Config.ConfigError, InitReq>): Layer.Layer<Registry, never, Cloudflare.Providers | Exclude<InitReq, Registry | import("alchemy/Named").Tag<"Cloudflare.Worker"> | Cloudflare.WorkerServices> | Exclude<PropsReq, Registry | import("alchemy/Named").Tag<"Cloudflare.Worker"> | Cloudflare.WorkerServices>>;
+};
+/**
+ * The registry Worker. Its props are an Effect so the same declaration
+ * serves both sides of the bundle boundary: at plan time
+ * {@link RegistryConfig} is the caller's options, inside the isolate it is
+ * rebuilt from the Worker's bindings.
+ */
+export declare class Registry extends Registry_base {
+}
+/**
+ * The bundle entry. `RegistryLive` names this file as `main`, so the
+ * generated Worker entry imports this default export and builds it once per
+ * isolate. User code never imports it; use {@link PkgRegistry}.
+ */
+declare const _default: Layer.Layer<Registry, never, Cloudflare.Providers | Cloudflare.WorkerEnvironment>;
+export default _default;
+/**
+ * A preview package registry: a Worker serving install URLs and the publish
+ * API, an R2 bucket of content-addressed tarballs, a D1 index of tags, and a
+ * KV namespace caching what the Worker learns from GitHub. They are declared
+ * under `id` as `<id>/Worker`, `<id>/Bucket`, `<id>/Database`, and
+ * `<id>/Cache`.
+ *
+ * ### Deploying a registry
+ * **Example:** Stack
+ * ```typescript
+ * // stacks/pkg.ts
+ * import { PkgRegistry } from "@alchemy.run/pkg/Registry";
+ * import * as Alchemy from "alchemy";
+ * import * as Cloudflare from "alchemy/Cloudflare";
+ * import * as ByteSize from "effect/ByteSize";
+ * import * as Config from "effect/Config";
+ * import * as Duration from "effect/Duration";
+ * import * as Effect from "effect/Effect";
+ *
+ * export default Alchemy.Stack(
+ *   "Pkg",
+ *   { providers: Cloudflare.providers(), state: Cloudflare.state() },
+ *   Effect.gen(function* () {
+ *     const registry = yield* PkgRegistry("Pkg", {
+ *       worker: { domain: "pkg.alchemy.run" },
+ *       github: {
+ *         appId: Config.String("GH_APP_ID"),
+ *         privateKey: Config.Redacted("GH_APP_PRIVATE_KEY"),
+ *       },
+ *       policy: {
+ *         repos: ["alchemy-run/alchemy", "alchemy-run/distilled"],
+ *         ttl: Duration.weeks(1),
+ *         maxPackageSize: ByteSize.megabytes(100),
+ *       },
+ *     });
+ *     return { url: registry.url.as<string>() };
+ *   }),
+ * );
+ * ```
+ *
+ * @resource
+ * @product Workers
+ * @category Workers & Compute
+ */
+export declare const PkgRegistry: <const Id extends string>(id: Id, options: RegistryOptions) => Effect.Effect<import("effect/Pipeable").Pipeable & import("alchemy").ResourceLike<"Cloudflare.Worker", Cloudflare.WorkerProps<any, Cloudflare.WorkerAssetsConfig | undefined>, {
+    workerId: string;
+    workerName: string;
+    namespace: string | undefined;
+    logpush: boolean | undefined;
+    url: string | undefined;
+    urls: string[];
+    domain: {
+        name: string;
+        aliases: string[];
+        redirects: string[];
+        zone?: Cloudflare.Zone.Reference;
+        previews?: boolean;
+    } | undefined;
+    tags: string[] | undefined;
+    durableObjectNamespaces: Record<string, string>;
+    accountId: string;
+    routes: {
+        id: string;
+        pattern: string;
+        zoneId: string;
+    }[];
+    crons: string[];
+    tailConsumers?: {
+        service: string;
+    }[] | undefined;
+    streamingTailConsumers?: {
+        service: string;
+    }[] | undefined;
+    versionOf?: string | undefined;
+    previewOf?: string | undefined;
+    previewId?: string | undefined;
+    previewName?: string | undefined;
+    previewSlug?: string | undefined;
+    previewDoClasses?: string[] | undefined;
+    versionId?: string | undefined;
+    versionAlias?: string | undefined;
+    deploymentId?: string | undefined;
+    affinityZoneIds?: string[] | undefined;
+    hash?: {
+        assets: string | undefined;
+        bundle: string | undefined;
+        input: string | undefined;
+        additionalWorkspaces: string[] | undefined;
+        metadata?: string | undefined;
+    };
+}, {
+    bindings?: Cloudflare.WorkerBinding[];
+    env?: Record<string, any>;
+    cache?: Cloudflare.WorkerCache;
+    observability?: Pick<Cloudflare.WorkerObservability, "traces">;
+    containers?: {
+        className: string;
+        dev: Cloudflare.DevContainerImage | undefined;
+        hash: string | undefined;
+    }[];
+    crons?: string[];
+    hyperdrives?: Record<string, Required<Cloudflare.Hyperdrive.DevOrigin>>;
+    devRemote?: Record<string, boolean>;
+}, Cloudflare.Providers> & {
+    bind(sid: import("alchemy").Input<string>, binding: import("alchemy").Input<{
+        bindings?: Cloudflare.WorkerBinding[];
+        env?: Record<string, any>;
+        cache?: Cloudflare.WorkerCache;
+        observability?: Pick<Cloudflare.WorkerObservability, "traces">;
+        containers?: {
+            className: string;
+            dev: Cloudflare.DevContainerImage | undefined;
+            hash: string | undefined;
+        }[];
+        crons?: string[];
+        hyperdrives?: Record<string, Required<Cloudflare.Hyperdrive.DevOrigin>>;
+        devRemote?: Record<string, boolean>;
+    }>): Effect.Effect<void>;
+    bind(template: TemplateStringsArray, ...args: any[]): (binding: import("alchemy").Input<{
+        bindings?: Cloudflare.WorkerBinding[];
+        env?: Record<string, any>;
+        cache?: Cloudflare.WorkerCache;
+        observability?: Pick<Cloudflare.WorkerObservability, "traces">;
+        containers?: {
+            className: string;
+            dev: Cloudflare.DevContainerImage | undefined;
+            hash: string | undefined;
+        }[];
+        crons?: string[];
+        hyperdrives?: Record<string, Required<Cloudflare.Hyperdrive.DevOrigin>>;
+        devRemote?: Record<string, boolean>;
+    }>) => Effect.Effect<void>;
+} & {
+    workerId: import("alchemy").Output<string, never>;
+    workerName: import("alchemy").Output<string, never>;
+    namespace: import("alchemy").Output<string | undefined, never>;
+    logpush: import("alchemy").Output<boolean | undefined, never>;
+    url: import("alchemy").Output<string | undefined, never>;
+    urls: import("alchemy").Output<string[], never>;
+    domain: import("alchemy").Output<{
+        name: string;
+        aliases: string[];
+        redirects: string[];
+        zone?: Cloudflare.Zone.Reference;
+        previews?: boolean;
+    } | undefined, never>;
+    tags: import("alchemy").Output<string[] | undefined, never>;
+    durableObjectNamespaces: import("alchemy/Output").ObjectExpr<Record<string, string>, never>;
+    accountId: import("alchemy").Output<string, never>;
+    routes: import("alchemy").Output<{
+        id: string;
+        pattern: string;
+        zoneId: string;
+    }[], never>;
+    crons: import("alchemy").Output<string[], never>;
+    tailConsumers: import("alchemy").Output<{
+        service: string;
+    }[] | undefined, never>;
+    streamingTailConsumers: import("alchemy").Output<{
+        service: string;
+    }[] | undefined, never>;
+    versionOf: import("alchemy").Output<string | undefined, never>;
+    previewOf: import("alchemy").Output<string | undefined, never>;
+    previewId: import("alchemy").Output<string | undefined, never>;
+    previewName: import("alchemy").Output<string | undefined, never>;
+    previewSlug: import("alchemy").Output<string | undefined, never>;
+    previewDoClasses: import("alchemy").Output<string[] | undefined, never>;
+    versionId: import("alchemy").Output<string | undefined, never>;
+    versionAlias: import("alchemy").Output<string | undefined, never>;
+    deploymentId: import("alchemy").Output<string | undefined, never>;
+    affinityZoneIds: import("alchemy").Output<string[] | undefined, never>;
+    hash: import("alchemy").Output<{
+        assets: string | undefined;
+        bundle: string | undefined;
+        input: string | undefined;
+        additionalWorkspaces: string[] | undefined;
+        metadata?: string | undefined;
+    } | undefined, never>;
+} & Cloudflare.Rpc<Registry> & import("alchemy").Dependencies<never>, never, Cloudflare.Providers>;
+//# sourceMappingURL=Registry.d.ts.map

package/dist/Registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Registry.d.ts","sourceRoot":"","sources":["../src/Registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,UAAU,MAAM,oBAAoB,CAAC;AAEjD,OAAO,KAAK,KAAK,QAAQ,MAAM,iBAAiB,CAAC;AACjD,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,KAAK,QAAQ,MAAM,iBAAiB,CAAC;AACjD,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AAEtC,OAAO,EASL,KAAK,iBAAiB,EACtB,KAAK,eAAe,EACrB,MAAM,wBAAwB,CAAC;AAGhC,OAAO,EACL,MAAM,EACN,KAAK,EACL,QAAQ,EACR,MAAM,EACN,cAAc,EACd,QAAQ,GACT,MAAM,wBAAwB,CAAC;AAEhC,MAAM,WAAW,eAAe;IAC9B;;;;OAIG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,eAAe,CAAC;IAClC,2EAA2E;IAC3E,QAAQ,CAAC,MAAM,EAAE,iBAAiB,GAAG;QACnC,wCAAwC;QACxC,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;KAC1B,CAAC;IACF,QAAQ,CAAC,MAAM,EAAE;QACf,wDAAwD;QACxD,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;QACtC,iCAAiC;QACjC,QAAQ,CAAC,GAAG,CAAC,EAAE,QAAQ,CAAC,QAAQ,CAAC;QACjC,+DAA+D;QAC/D,QAAQ,CAAC,cAAc,CAAC,EAAE,QAAQ,CAAC,QAAQ,CAAC;KAC7C,CAAC;IACF;;;;OAIG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IACpD;;;OAGG;IACH,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;CACxB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAED;;;;;GAKG;AACH,qBAAa,QAAS,SAAQ,aAA2C;CAAG;AA8C5E;;;;GAIG;;;AAGH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,eAAO,MAAM,WAAW,GAAI,KAAK,CAAC,EAAE,SAAS,MAAM,MAC7C,EAAE,WACG,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kGA2BvB,CAAC"}

package/dist/Registry.js

@@ -0,0 +1,119 @@
+import * as Cloudflare from "alchemy/Cloudflare";
+import * as Namespace from "alchemy/Namespace";
+import * as Config from "effect/Config";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Schema from "effect/Schema";
+import { APP_ID_ENV, DEFAULT_API_URL, DEFAULT_CRON, DEFAULT_TTL, PRIVATE_KEY_ENV, RegistryConfig, SETTINGS_ENV, Settings, } from "./Registry/Bindings.js";
+import { handler } from "./Registry/Handler.js";
+export { Bucket, Cache, Database, Policy, RegistryConfig, Settings, } from "./Registry/Bindings.js";
+/**
+ * The registry Worker. Its props are an Effect so the same declaration
+ * serves both sides of the bundle boundary: at plan time
+ * {@link RegistryConfig} is the caller's options, inside the isolate it is
+ * rebuilt from the Worker's bindings.
+ */
+export class Registry extends Cloudflare.Worker()("Worker") {
+}
+const RegistryLive = Registry.make(Effect.gen(function* () {
+    const config = yield* RegistryConfig;
+    return {
+        ...config.worker,
+        main: import.meta.url,
+        env: {
+            [SETTINGS_ENV]: yield* Schema.encodeEffect(Settings)({
+                policy: config.policy,
+                aliases: config.aliases,
+                cron: config.cron,
+                github: { apiUrl: config.github.apiUrl },
+            }).pipe(Effect.orDie),
+            [APP_ID_ENV]: config.github.appId,
+            [PRIVATE_KEY_ENV]: config.github.privateKey,
+        },
+    };
+}), handler);
+/**
+ * Runtime side of {@link RegistryConfig}: decode the settings binding and
+ * point the credentials at the bindings `RegistryLive` declared.
+ */
+const RegistryConfigFromEnv = Layer.effect(RegistryConfig, Effect.gen(function* () {
+    const env = yield* Cloudflare.Workers.WorkerEnvironment;
+    const settings = yield* Schema.decodeUnknownEffect(Settings)(env[SETTINGS_ENV]).pipe(Effect.orDie);
+    return {
+        ...settings,
+        worker: {},
+        github: {
+            ...settings.github,
+            appId: Config.String(APP_ID_ENV),
+            privateKey: Config.Redacted(PRIVATE_KEY_ENV),
+        },
+    };
+}));
+/**
+ * The bundle entry. `RegistryLive` names this file as `main`, so the
+ * generated Worker entry imports this default export and builds it once per
+ * isolate. User code never imports it; use {@link PkgRegistry}.
+ */
+export default RegistryLive.pipe(Layer.provide(RegistryConfigFromEnv));
+/**
+ * A preview package registry: a Worker serving install URLs and the publish
+ * API, an R2 bucket of content-addressed tarballs, a D1 index of tags, and a
+ * KV namespace caching what the Worker learns from GitHub. They are declared
+ * under `id` as `<id>/Worker`, `<id>/Bucket`, `<id>/Database`, and
+ * `<id>/Cache`.
+ *
+ * ### Deploying a registry
+ * **Example:** Stack
+ * ```typescript
+ * // stacks/pkg.ts
+ * import { PkgRegistry } from "@alchemy.run/pkg/Registry";
+ * import * as Alchemy from "alchemy";
+ * import * as Cloudflare from "alchemy/Cloudflare";
+ * import * as ByteSize from "effect/ByteSize";
+ * import * as Config from "effect/Config";
+ * import * as Duration from "effect/Duration";
+ * import * as Effect from "effect/Effect";
+ *
+ * export default Alchemy.Stack(
+ *   "Pkg",
+ *   { providers: Cloudflare.providers(), state: Cloudflare.state() },
+ *   Effect.gen(function* () {
+ *     const registry = yield* PkgRegistry("Pkg", {
+ *       worker: { domain: "pkg.alchemy.run" },
+ *       github: {
+ *         appId: Config.String("GH_APP_ID"),
+ *         privateKey: Config.Redacted("GH_APP_PRIVATE_KEY"),
+ *       },
+ *       policy: {
+ *         repos: ["alchemy-run/alchemy", "alchemy-run/distilled"],
+ *         ttl: Duration.weeks(1),
+ *         maxPackageSize: ByteSize.megabytes(100),
+ *       },
+ *     });
+ *     return { url: registry.url.as<string>() };
+ *   }),
+ * );
+ * ```
+ *
+ * @resource
+ * @product Workers
+ * @category Workers & Compute
+ */
+export const PkgRegistry = (id, options) => Registry.pipe(Effect.provide(RegistryLive.pipe(Layer.provide(Layer.succeed(RegistryConfig, {
+    worker: options.worker ?? {},
+    policy: {
+        repos: options.policy.repos,
+        ttl: options.policy.ttl ?? DEFAULT_TTL,
+        ...(options.policy.maxPackageSize !== undefined
+            ? { maxPackageSize: options.policy.maxPackageSize }
+            : {}),
+    },
+    aliases: options.aliases ?? {},
+    cron: options.cron ?? DEFAULT_CRON,
+    github: {
+        apiUrl: options.github.apiUrl ?? DEFAULT_API_URL,
+        appId: options.github.appId,
+        privateKey: options.github.privateKey,
+    },
+})))), Namespace.push(id));
+//# sourceMappingURL=Registry.js.map

package/dist/Registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Registry.js","sourceRoot":"","sources":["../src/Registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,UAAU,MAAM,oBAAoB,CAAC;AACjD,OAAO,KAAK,SAAS,MAAM,mBAAmB,CAAC;AAE/C,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAExC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AACtC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,EACL,UAAU,EACV,eAAe,EACf,YAAY,EACZ,WAAW,EACX,eAAe,EACf,cAAc,EACd,YAAY,EACZ,QAAQ,GAGT,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAEhD,OAAO,EACL,MAAM,EACN,KAAK,EACL,QAAQ,EACR,MAAM,EACN,cAAc,EACd,QAAQ,GACT,MAAM,wBAAwB,CAAC;AAmChC;;;;;GAKG;AACH,MAAM,OAAO,QAAS,SAAQ,UAAU,CAAC,MAAM,EAAgB,CAAC,QAAQ,CAAC;CAAG;AAE5E,MAAM,YAAY,GAAG,QAAQ,CAAC,IAAI,CAChC,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC;IAClB,MAAM,MAAM,GAAG,KAAK,CAAC,CAAC,cAAc,CAAC;IACrC,OAAO;QACL,GAAG,MAAM,CAAC,MAAM;QAChB,IAAI,EAAE,OAAO,IAAI,CAAC,GAAG;QACrB,GAAG,EAAE;YACH,CAAC,YAAY,CAAC,EAAE,KAAK,CAAC,CAAC,MAAM,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC;gBACnD,MAAM,EAAE,MAAM,CAAC,MAAM;gBACrB,OAAO,EAAE,MAAM,CAAC,OAAO;gBACvB,IAAI,EAAE,MAAM,CAAC,IAAI;gBACjB,MAAM,EAAE,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE;aACzC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC;YACrB,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,CAAC,KAAK;YACjC,CAAC,eAAe,CAAC,EAAE,MAAM,CAAC,MAAM,CAAC,UAAU;SAC5C;KACF,CAAC;AACJ,CAAC,CAAC,EACF,OAAO,CACR,CAAC;AAEF;;;GAGG;AACH,MAAM,qBAAqB,GAAG,KAAK,CAAC,MAAM,CACxC,cAAc,EACd,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC;IAClB,MAAM,GAAG,GAAG,KAAK,CAAC,CAAC,UAAU,CAAC,OAAO,CAAC,iBAAiB,CAAC;IACxD,MAAM,QAAQ,GAAG,KAAK,CAAC,CAAC,MAAM,CAAC,mBAAmB,CAAC,QAAQ,CAAC,CAC1D,GAAG,CAAC,YAAY,CAAC,CAClB,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;IACrB,OAAO;QACL,GAAG,QAAQ;QACX,MAAM,EAAE,EAAE;QACV,MAAM,EAAE;YACN,GAAG,QAAQ,CAAC,MAAM;YAClB,KAAK,EAAE,MAAM,CAAC,MAAM,CAAC,UAAU,CAAC;YAChC,UAAU,EAAE,MAAM,CAAC,QAAQ,CAAC,eAAe,CAAC;SAC7C;KACF,CAAC;AACJ,CAAC,CAAC,CACH,CAAC;AAEF;;;;GAIG;AACH,eAAe,YAAY,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,qBAAqB,CAAC,CAAC,CAAC;AAEvE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,CACzB,EAAM,EACN,OAAwB,EACxB,EAAE,CACF,QAAQ,CAAC,IAAI,CACX,MAAM,CAAC,OAAO,CACZ,YAAY,CAAC,IAAI,CACf,KAAK,CAAC,OAAO,CACX,KAAK,CAAC,OAAO,CAAC,cAAc,EAAE;IAC5B,MAAM,EAAE,OAAO,CAAC,MAAM,IAAI,EAAE;IAC5B,MAAM,EAAE;QACN,KAAK,EAAE,OAAO,CAAC,MAAM,CAAC,KAAK;QAC3B,GAAG,EAAE,OAAO,CAAC,MAAM,CAAC,GAAG,IAAI,WAAW;QACtC,GAAG,CAAC,OAAO,CAAC,MAAM,CAAC,cAAc,KAAK,SAAS;YAC7C,CAAC,CAAC,EAAE,cAAc,EAAE,OAAO,CAAC,MAAM,CAAC,cAAc,EAAE;YACnD,CAAC,CAAC,EAAE,CAAC;KACR;IACD,OAAO,EAAE,OAAO,CAAC,OAAO,IAAI,EAAE;IAC9B,IAAI,EAAE,OAAO,CAAC,IAAI,IAAI,YAAY;IAClC,MAAM,EAAE;QACN,MAAM,EAAE,OAAO,CAAC,MAAM,CAAC,MAAM,IAAI,eAAe;QAChD,KAAK,EAAE,OAAO,CAAC,MAAM,CAAC,KAAK;QAC3B,UAAU,EAAE,OAAO,CAAC,MAAM,CAAC,UAAU;KACtC;CACF,CAAC,CACH,CACF,CACF,EACD,SAAS,CAAC,IAAI,CAAC,EAAE,CAAC,CACnB,CAAC"}

package/dist/cli/bin.d.ts

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+import * as Config from "effect/Config";
+import { CliError, Command } from "effect/unstable/cli";
+export declare const packCommand: Command.Command<"pack", {
+    readonly group: readonly {
+        readonly name: string;
+        readonly pattern: string;
+        readonly collapsed: boolean;
+    }[];
+    readonly registry: string;
+    readonly out: string;
+}, {}, Config.ConfigError | import("./pack.ts").GitError | import("./pack.ts").PackError | import("effect/PlatformError").PlatformError | import("effect/Schema").SchemaError | import("./pack.ts").WorkspaceError, import("effect/unstable/process/ChildProcessSpawner").ChildProcessSpawner | import("effect/FileSystem").FileSystem | import("effect/Path").Path>;
+export declare const publishCommand: Command.Command<"publish", {
+    readonly registry: string;
+    readonly dir: string;
+}, {}, import("effect/PlatformError").PlatformError | import("./publish.ts").PublishError | import("effect/Schema").SchemaError, import("effect/FileSystem").FileSystem | import("effect/unstable/http/HttpClient").HttpClient | import("effect/Path").Path>;
+export declare const root: Command.Command<"pkg", {} | {}, {}, Config.ConfigError | import("./pack.ts").GitError | import("./pack.ts").PackError | import("effect/PlatformError").PlatformError | import("./publish.ts").PublishError | import("effect/Schema").SchemaError | CliError.ShowHelp | import("./pack.ts").WorkspaceError, import("effect/unstable/process/ChildProcessSpawner").ChildProcessSpawner | import("effect/FileSystem").FileSystem | import("effect/unstable/http/HttpClient").HttpClient | import("effect/Path").Path>;
+//# sourceMappingURL=bin.d.ts.map

package/dist/cli/bin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bin.d.ts","sourceRoot":"","sources":["../../src/cli/bin.ts"],"names":[],"mappings":";AAEA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAGxC,OAAO,EAEL,QAAQ,EACR,OAAO,EAGR,MAAM,qBAAqB,CAAC;AA2B7B,eAAO,MAAM,WAAW;;;;;;;;oWAkBvB,CAAC;AAOF,eAAO,MAAM,cAAc;;;4PAe1B,CAAC;AAEF,eAAO,MAAM,IAAI,ofAOhB,CAAC"}

package/dist/cli/bin.js

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+import { PlatformServices, runMain } from "alchemy/Util/PlatformServices";
+import * as Config from "effect/Config";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import { CliConfig, CliError, Command, Flag, GlobalFlag, } from "effect/unstable/cli";
+import * as FetchHttpClient from "effect/unstable/http/FetchHttpClient";
+import pkg from "../../package.json" with { type: "json" };
+import { Group, pack } from "./pack.js";
+import { publish } from "./publish.js";
+const groupFlag = Flag.String("group").pipe(Flag.withDescription("Display group and directory glob, as NAME=GLOB or NAME[Collapsed]=GLOB (repeatable), e.g. --group Alchemy=./packages/*"), Flag.withSchema(Group), Flag.atLeast(1));
+const registryFlag = Flag.String("registry").pipe(Flag.withDescription("Registry origin used for install URLs. Falls back to PKG_REGISTRY, then https://pkg.alchemy.run"), Flag.withFallbackConfig(Config.String("PKG_REGISTRY")), Flag.withDefault("https://pkg.alchemy.run"));
+const outFlag = Flag.String("out").pipe(Flag.withDescription("Directory to write tarballs and the manifest into"), Flag.withDefault(".pkg"));
+export const packCommand = Command.make("pack", { group: groupFlag, registry: registryFlag, out: outFlag }, ({ group, registry, out }) => Effect.gen(function* () {
+    const cwd = yield* Effect.sync(() => process.cwd());
+    yield* pack({ cwd, groups: group, registry, out });
+})).pipe(Command.withDescription("Pack workspace packages into reproducible tarballs with dependencies rewritten to registry URLs"), Command.withExamples([
+    {
+        command: "pkg pack --group 'alchemy=./packages/alchemy' --group '@alchemy.run[Collapsed]=./packages/{better-auth,pkg}' --group '@distilled.cloud[Collapsed]=./submodules/distilled/packages/*'",
+    },
+]));
+const dirFlag = Flag.String("dir").pipe(Flag.withDescription("Directory written by pkg pack"), Flag.withDefault(".pkg"));
+export const publishCommand = Command.make("publish", { registry: registryFlag, dir: dirFlag }, ({ registry, dir }) => Effect.gen(function* () {
+    const cwd = yield* Effect.sync(() => process.cwd());
+    yield* publish({ cwd, dir, registry });
+})).pipe(Command.withDescription("Publish a pkg pack directory from the current GitHub Actions job, after its manifest artifact has been uploaded"), Command.withExamples([
+    { command: "pkg publish --registry https://pkg.alchemy.run" },
+]));
+export const root = Command.make("pkg", {}, () => Effect.fail(new CliError.ShowHelp({ commandPath: ["pkg"], errors: [] }))).pipe(Command.withDescription("Pack and publish preview packages for pull requests."), Command.withSubcommands([packCommand, publishCommand]));
+Command.run(root, { version: pkg.version }).pipe(Effect.provide(Layer.mergeAll(PlatformServices, FetchHttpClient.layer, CliConfig.layer({
+    builtIns: [GlobalFlag.Help, GlobalFlag.Version],
+}))), runMain);
+//# sourceMappingURL=bin.js.map