@homeflare/alchemy 0.30.0 → 0.31.0

package/README.md

@@ -249,6 +249,28 @@ endpoint lives in ONE `general_settings` field (a whole-list read-modify-write),
 declared in `config.yaml` is refused rather than silently overridden, and a literal secret in a
 forwarded header is refused at plan: [docs/litellm.md](./docs/litellm.md).
 
+## Discord — `@homeflare/alchemy/discord`
+
+`Discord.ApplicationCommand` (global) and `Discord.GuildApplicationCommand` (guild-scoped)
+declare a slash/user/message command, generated from Discord API v10 via
+`@distilled.cloud/discord`. `reconcile` is one upsert call — Discord's own create endpoint
+overwrites a command with the same name. ⛔ `read` answers `Unowned` on every match (never a
+silent adopt — `adopt(true)` is on by default on both constructors), and declaring
+`Discord.GuildApplicationCommand` against a guild `hf-discord-halibut.service` still
+self-registers into fights the bot, not replaces it: [docs/discord.md](./docs/discord.md).
+
+```ts
+import { applicationCommand, guildApplicationCommand, providers } from '@homeflare/alchemy/discord';
+
+export const help =
+  yield *
+  applicationCommand('help', {
+    applicationId: '123456789012345678',
+    name: 'help',
+    description: 'Show available commands',
+  });
+```
+
 ## Google Workspace — `@homeflare/alchemy/google-workspace`
 
 `Group`, `GroupMember`, `DomainAlias` and `OrgUnit` over the Admin SDK Directory API, generated

package/dist/discord/application-command.d.ts

@@ -0,0 +1,52 @@
+import { Resource } from 'alchemy';
+import * as Provider from 'alchemy/Provider';
+import * as command from '@distilled.cloud/discord/discord';
+import type { DiscordOpError } from '@distilled.cloud/discord/Protocol';
+import * as Effect from 'effect/Effect';
+import { type CommandFields, type CommandFieldsAttributes } from './command-form.ts';
+import type { DiscordRequirements, DiscordSpec } from './resource.ts';
+export interface ApplicationCommandProps extends CommandFields {
+    /** The Discord application (bot) this command belongs to — a public snowflake, not a secret. */
+    applicationId: string;
+}
+export interface ApplicationCommandAttributes extends CommandFieldsAttributes {
+    commandId: string;
+    applicationId: string;
+    version: string;
+}
+export interface DiscordApplicationCommand extends Resource<'Discord.ApplicationCommand', ApplicationCommandProps, ApplicationCommandAttributes, never, DiscordRequirements> {
+}
+export declare const DiscordApplicationCommand: import("alchemy").ResourceClass<DiscordApplicationCommand>;
+export declare const isDiscordApplicationCommand: (value: unknown) => value is DiscordApplicationCommand;
+/** Exported for direct testing against `fake-discord.ts` — the same seam `../netbox/prefix.ts` uses. */
+export declare const spec: DiscordSpec<ApplicationCommandProps, command.ApplicationCommandResponse, ApplicationCommandAttributes, DiscordOpError>;
+export declare const handlers: {
+    list: () => Effect.Effect<never[], never, never>;
+    read: ({ olds, output }: {
+        olds: ApplicationCommandProps;
+        output: ApplicationCommandAttributes | undefined;
+    }) => Effect.Effect<ApplicationCommandAttributes | undefined, DiscordOpError, import("effect/unstable/http/HttpClient").HttpClient>;
+    diff: ({ news, output }: {
+        news: import("alchemy").Input<ApplicationCommandProps>;
+        output: ApplicationCommandAttributes | undefined;
+    }) => Effect.Effect<{
+        readonly action: 'update';
+    } | {
+        readonly action: 'noop';
+    } | undefined, DiscordOpError, import("effect/unstable/http/HttpClient").HttpClient>;
+    reconcile: ({ news }: {
+        news: ApplicationCommandProps;
+    }) => Effect.Effect<ApplicationCommandAttributes, DiscordOpError, import("effect/unstable/http/HttpClient").HttpClient>;
+    delete: ({ olds }: {
+        olds: ApplicationCommandProps;
+    }) => Effect.Effect<void, DiscordOpError, import("effect/unstable/http/HttpClient").HttpClient>;
+};
+export declare const DiscordApplicationCommandProvider: () => import("effect/Layer").Layer<Provider.Provider<DiscordApplicationCommand>, never, import("effect/unstable/http/HttpClient").HttpClient>;
+/**
+ * `applicationCommand('help', { applicationId, name: 'help', description: '…' })` — `adopt(true)`
+ *   piped on by default (H5), so a first deploy against a command that already exists silently
+ *   takes it over instead of failing `OwnedBySomeoneElse`. Mirrors `cloudflare/website.ts`'s
+ *   `astroWebsite`/`viteWebsite` convenience constructors.
+ */
+export declare const applicationCommand: (id: string, props: ApplicationCommandProps) => Effect.Effect<DiscordApplicationCommand, never, import("effect/unstable/http/HttpClient").HttpClient>;
+//# sourceMappingURL=application-command.d.ts.map

package/dist/discord/application-command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"application-command.d.ts","sourceRoot":"","sources":["../../src/discord/application-command.ts"],"names":[],"mappings":"AAeA,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACnC,OAAO,KAAK,QAAQ,MAAM,kBAAkB,CAAC;AAC7C,OAAO,KAAK,OAAO,MAAM,kCAAkC,CAAC;AAC5D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mCAAmC,CAAC;AACxE,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,EACL,KAAK,aAAa,EAClB,KAAK,uBAAuB,EAI7B,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,mBAAmB,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAGtE,MAAM,WAAW,uBAAwB,SAAQ,aAAa;IAC5D,gGAAgG;IAChG,aAAa,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,4BAA6B,SAAQ,uBAAuB;IAC3E,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,EAAE,MAAM,CAAC;IACtB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,yBAA0B,SAAQ,QAAQ,CACzD,4BAA4B,EAC5B,uBAAuB,EACvB,4BAA4B,EAC5B,KAAK,EACL,mBAAmB,CACpB;CAAG;AAEJ,eAAO,MAAM,yBAAyB,4DAMrC,CAAC;AAEF,eAAO,MAAM,2BAA2B,UAAW,OAAO,KAAG,KAAK,IAAI,yBAGD,CAAC;AAStE,wGAAwG;AACxG,eAAO,MAAM,IAAI,EAAE,WAAW,CAC5B,uBAAuB,EACvB,OAAO,CAAC,0BAA0B,EAClC,4BAA4B,EAC5B,cAAc,CAiBf,CAAC;AAEF,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;CAAwB,CAAC;AAE9C,eAAO,MAAM,iCAAiC,+IAI3C,CAAC;AAEJ;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,OAAQ,MAAM,SAAS,uBAAuB,0GACrB,CAAC"}

package/dist/discord/command-form.d.ts

@@ -0,0 +1,62 @@
+/** Fields every Discord command shares, independent of global vs. guild scope. */
+export interface CommandFields {
+    readonly name: string;
+    readonly description?: string;
+    /**
+     * ⚠️ GAP: passed through opaquely, not re-modeled. The SDK's generated option union is ~40
+     *   nested schema types (subcommand, subcommand group, string/int/number/channel/role/user/
+     *   mentionable/attachment, each with its own choices and localizations) — see
+     *   `docs/upstream-conformance.md#discord`. A caller supplies the exact wire shape from
+     *   Discord's own docs; this resource neither validates nor transforms it.
+     */
+    readonly options?: readonly Record<string, unknown>[];
+    /** Bitfield, stringified, per Discord's real wire contract (the SDK types write as `number`). */
+    readonly defaultMemberPermissions?: string;
+    readonly dmPermission?: boolean;
+    readonly contexts?: readonly number[];
+    readonly integrationTypes?: readonly number[];
+    readonly nsfw?: boolean;
+    /** `ApplicationCommandType`; omitted means `1` (`CHAT_INPUT`), Discord's own default. */
+    readonly type?: number;
+}
+export interface CommandFieldsAttributes {
+    readonly name: string;
+    readonly description: string;
+    readonly options: readonly Record<string, unknown>[];
+    readonly defaultMemberPermissions: string | undefined;
+    readonly dmPermission: boolean | undefined;
+    readonly contexts: readonly number[] | undefined;
+    readonly integrationTypes: readonly number[] | undefined;
+    readonly nsfw: boolean;
+    readonly type: number;
+}
+/**
+ * ⛔ SENT IN FULL ON EVERY UPSERT, NEVER PARTIAL. Discord's create-as-upsert (resource.ts's own
+ *   note) replaces the whole command, so a body that omitted a field the caller stopped declaring
+ *   would never actually clear it — the same "declared, then forgotten" bug `prefix-form.ts`
+ *   documents for NetBox's PATCH. Sending the full settled shape every time is what keeps a
+ *   removed prop actually removed live, not just removed from the declaration.
+ */
+export declare const commandBody: (props: CommandFields) => Record<string, unknown>;
+/** Whether the live command already says what the declaration says. */
+export declare const commandMatches: (attributes: CommandFieldsAttributes, props: CommandFields) => boolean;
+/**
+ * Reads the shared fields off any `ApplicationCommandResponse`-shaped object.
+ *
+ * ⚠️ `options` IS READ AS `readonly unknown[]`, NOT RE-TYPED. The SDK's real
+ *   `ApplicationCommandResponseOptionsItem` union has no index signature (each option kind is a
+ *   distinct generated interface), so it cannot structurally satisfy `Record<string, unknown>`
+ *   without a cast — the same "opaque passthrough" gap `CommandFields.options` documents above.
+ */
+export declare const commandFieldsOf: (live: {
+    readonly name: string;
+    readonly description: string;
+    readonly options?: readonly unknown[] | null | undefined;
+    readonly default_member_permissions?: string | null | undefined;
+    readonly dm_permission?: boolean | undefined;
+    readonly contexts?: readonly number[] | null | undefined;
+    readonly integration_types?: readonly number[] | null | undefined;
+    readonly nsfw?: boolean | undefined;
+    readonly type: number;
+}) => CommandFieldsAttributes;
+//# sourceMappingURL=command-form.d.ts.map

package/dist/discord/command-form.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"command-form.d.ts","sourceRoot":"","sources":["../../src/discord/command-form.ts"],"names":[],"mappings":"AAQA,kFAAkF;AAClF,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B;;;;;;OAMG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC;IACtD,iGAAiG;IACjG,QAAQ,CAAC,wBAAwB,CAAC,EAAE,MAAM,CAAC;IAC3C,QAAQ,CAAC,YAAY,CAAC,EAAE,OAAO,CAAC;IAChC,QAAQ,CAAC,QAAQ,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACtC,QAAQ,CAAC,gBAAgB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC9C,QAAQ,CAAC,IAAI,CAAC,EAAE,OAAO,CAAC;IACxB,yFAAyF;IACzF,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,OAAO,EAAE,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC;IACrD,QAAQ,CAAC,wBAAwB,EAAE,MAAM,GAAG,SAAS,CAAC;IACtD,QAAQ,CAAC,YAAY,EAAE,OAAO,GAAG,SAAS,CAAC;IAC3C,QAAQ,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,GAAG,SAAS,CAAC;IACjD,QAAQ,CAAC,gBAAgB,EAAE,SAAS,MAAM,EAAE,GAAG,SAAS,CAAC;IACzD,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IACvB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAWD;;;;;;GAMG;AACH,eAAO,MAAM,WAAW,UAAW,aAAa,KAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAgBxE,CAAC;AAEF,uEAAuE;AACvE,eAAO,MAAM,cAAc,eACb,uBAAuB,SAC5B,aAAa,KACnB,OAsBF,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,eAAe,SAAU;IACpC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,OAAO,CAAC,EAAE,SAAS,OAAO,EAAE,GAAG,IAAI,GAAG,SAAS,CAAC;IACzD,QAAQ,CAAC,0BAA0B,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;IAChE,QAAQ,CAAC,aAAa,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IAC7C,QAAQ,CAAC,QAAQ,CAAC,EAAE,SAAS,MAAM,EAAE,GAAG,IAAI,GAAG,SAAS,CAAC;IACzD,QAAQ,CAAC,iBAAiB,CAAC,EAAE,SAAS,MAAM,EAAE,GAAG,IAAI,GAAG,SAAS,CAAC;IAClE,QAAQ,CAAC,IAAI,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IACpC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB,KAAG,uBAUF,CAAC"}

package/dist/discord/credentials.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Discord credentials — a bot token REFERENCE, resolved lazily (S24), never a prop.
+ *
+ * ⛔ NO TOKEN IS EVER A PROP OR AN ATTRIBUTE. Alchemy persists Attributes unencrypted
+ *   (State/StateEncoding.ts@v2.0.0-beta.79#encodeState), so nothing a stack file holds may be a
+ *   credential. `@distilled.cloud/discord/Credentials` already ships exactly the shape S24 asks
+ *   for: `Credentials` is a lazy `Context.Service<Credentials, Effect.Effect<Config>>`, resolved
+ *   on the calling fiber inside each operation (`DiscordProtocol`'s `credentials:` field), never
+ *   at layer build. This file re-exports it rather than re-implementing it — the same choice
+ *   `../netbox/resource.ts` made for `CredentialsFromEnv` — and adds only the house-specific
+ *   naming and doc trail.
+ *
+ * ★ `CredentialsFromEnv` reads `DISCORD_BOT_TOKEN` (falling back to `DISCORD_TOKEN`) via Effect's
+ *   `Config`, which is exactly the "reference" shape S25 asks for: the resource never sees the
+ *   value, only the environment variable NAME is anywhere near a stack file, and the value itself
+ *   is wrapped in `Redacted` the moment it is read.
+ *
+ * ⚠️ NO OpenBao MINT YET. H8's target (`Alchemy.Stack({ secrets })`) is unreleased (PR 1728, still
+ *   on `main` only). Until the estate is on a release that carries it, the deploy process's own
+ *   environment is the credential seam — a human or CI job exports `DISCORD_BOT_TOKEN` from
+ *   wherever it mints it (on CT100 today: `/opt/homeflare/env/discord-halibut.env`, read by
+ *   systemd's `EnvironmentFile=`, never by this package). This package never reads that file.
+ */
+import type { Config } from '@distilled.cloud/discord/Credentials';
+import { Credentials, CredentialsFromEnv, credentials } from '@distilled.cloud/discord/Credentials';
+/** Re-exported so a consumer never has to reach into `@distilled.cloud/discord` by hand. */
+export { Credentials, CredentialsFromEnv, credentials };
+export type { Config as DiscordCredentialsConfig };
+/**
+ * `DiscordCredentials.fromEnv()` — the layer every `discordProviders()` stack uses by default.
+ * A thin, named alias over `CredentialsFromEnv` so a stack's import reads `Discord.*`
+ * throughout, the way `../netbox/index.ts`'s barrel keeps `Netbox*` names at the front door.
+ */
+export declare const fromEnv: () => import("effect/Layer").Layer<Credentials, never, never>;
+//# sourceMappingURL=credentials.d.ts.map

package/dist/discord/credentials.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"credentials.d.ts","sourceRoot":"","sources":["../../src/discord/credentials.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sCAAsC,CAAC;AACnE,OAAO,EAAE,WAAW,EAAE,kBAAkB,EAAE,WAAW,EAAE,MAAM,sCAAsC,CAAC;AAEpG,4FAA4F;AAC5F,OAAO,EAAE,WAAW,EAAE,kBAAkB,EAAE,WAAW,EAAE,CAAC;AACxD,YAAY,EAAE,MAAM,IAAI,wBAAwB,EAAE,CAAC;AAEnD;;;;GAIG;AACH,eAAO,MAAM,OAAO,+DAA2B,CAAC"}

package/dist/discord/fake-discord.d.ts

@@ -0,0 +1,44 @@
+/**
+ * A minimal in-memory Discord REST API for this family's tests — an in-memory `fetch` handed to
+ * Effect's real `FetchHttpClient` through its `Fetch` reference, mirroring `../netbox/fake-netbox.ts`
+ * (itself mirroring `../forgejo/fake-forgejo.ts` and `cloudflare/fake-mesh.ts`). Tests exercise
+ * distilled's REAL path assembly, JSON encode/decode, status→typed-error matching AND its retry
+ * policy — nothing about any of that is re-implemented here, only the wire responses a scenario
+ * needs, including a `429` with a `Retry-After` header for the bounded-retry test.
+ *
+ * ⛔ TEST-ONLY, AND NO NETWORK. No provider imports this file. The base URL is RFC 2606
+ *   `discord.example.com`, and the token is a placeholder.
+ */
+import { type Credentials } from '@distilled.cloud/discord/Credentials';
+import * as Layer from 'effect/Layer';
+export declare const FAKE_BASE = "https://discord.example.com";
+export declare const FAKE_TOKEN = "placeholder-discord-token";
+export type Seen = {
+    readonly method: string;
+    readonly path: string;
+    readonly body: unknown;
+};
+/** Discord's `{ code, message }` failure envelope — matching `protocol.ts`'s `errorEnvelope`. */
+export declare const fakeFailure: (status: number, code: number, message: string, headers?: Record<string, string>) => Response;
+/** A `429` with `Retry-After` in seconds, Discord's real shape for a rate-limited response. */
+export declare const fakeRateLimited: (retryAfterSeconds: number) => Response;
+/**
+ * `route` decides every response; this wrapper only records what was sent and adapts to
+ * `globalThis.fetch`'s signature. A test that expects no request at all asserts `seen` is empty.
+ */
+export declare const fakeDiscord: (route: (method: string, url: URL, body: unknown, callNumber: number) => Response) => {
+    fetch: typeof fetch;
+    seen: Seen[];
+};
+/**
+ * distilled Credentials + the real FetchHttpClient over the fake — `DiscordOpContext`, what every
+ * resource file's exported `spec.fetchByName`/`spec.upsert`/`spec.destroy` needs.
+ *
+ * ⚠️ NOT PAIRED WITH `handlers` (each resource file's `discordHandlers(spec)` export). `handlers`
+ *   bakes in `CredentialsFromEnv`, which resolves through Effect's `Config` snapshot of
+ *   `process.env` — the same seam `../netbox/fake-netbox.ts` documents as untestable against a
+ *   fake server. So a test calls `spec.fetchByName`/`spec.upsert`/`spec.destroy` directly, with
+ *   this explicit layer, exercising exactly the same production code without that env seam.
+ */
+export declare const fakeDiscordLayer: (fetchFn: typeof globalThis.fetch, creds?: Layer.Layer<Credentials>) => Layer.Layer<Credentials | import("effect/unstable/http/HttpClient").HttpClient, never, never>;
+//# sourceMappingURL=fake-discord.d.ts.map

package/dist/discord/fake-discord.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fake-discord.d.ts","sourceRoot":"","sources":["../../src/discord/fake-discord.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,EAAE,KAAK,WAAW,EAAe,MAAM,sCAAsC,CAAC;AACrF,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AAGtC,eAAO,MAAM,SAAS,gCAAgC,CAAC;AACvD,eAAO,MAAM,UAAU,8BAA8B,CAAC;AAEtD,MAAM,MAAM,IAAI,GAAG;IAAE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;CAAE,CAAC;AAE9F,iGAAiG;AACjG,eAAO,MAAM,WAAW,WACd,MAAM,QACR,MAAM,WACH,MAAM,YACL,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,aAC6D,CAAC;AAEhG,+FAA+F;AAC/F,eAAO,MAAM,eAAe,sBAAuB,MAAM,aAGrD,CAAC;AAEL;;;GAGG;AACH,eAAO,MAAM,WAAW,UACf,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,KAAK,QAAQ;;;CAejF,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,gBAAgB,YAClB,OAAO,UAAU,CAAC,KAAK,UACzB,KAAK,CAAC,KAAK,CAAC,WAAW,CAAC,kGAC+D,CAAC"}

package/dist/discord/guild-application-command.d.ts

@@ -0,0 +1,53 @@
+import { Resource } from 'alchemy';
+import * as Provider from 'alchemy/Provider';
+import * as command from '@distilled.cloud/discord/discord';
+import type { DiscordOpError } from '@distilled.cloud/discord/Protocol';
+import * as Effect from 'effect/Effect';
+import { type CommandFields, type CommandFieldsAttributes } from './command-form.ts';
+import type { DiscordRequirements, DiscordSpec } from './resource.ts';
+export interface GuildApplicationCommandProps extends CommandFields {
+    /** The Discord application (bot) this command belongs to — a public snowflake, not a secret. */
+    applicationId: string;
+    /** The guild (server) this command is scoped to — a public snowflake. */
+    guildId: string;
+}
+export interface GuildApplicationCommandAttributes extends CommandFieldsAttributes {
+    commandId: string;
+    applicationId: string;
+    guildId: string;
+    version: string;
+}
+export interface DiscordGuildApplicationCommand extends Resource<'Discord.GuildApplicationCommand', GuildApplicationCommandProps, GuildApplicationCommandAttributes, never, DiscordRequirements> {
+}
+export declare const DiscordGuildApplicationCommand: import("alchemy").ResourceClass<DiscordGuildApplicationCommand>;
+export declare const isDiscordGuildApplicationCommand: (value: unknown) => value is DiscordGuildApplicationCommand;
+/** Exported for direct testing against `fake-discord.ts`. */
+export declare const spec: DiscordSpec<GuildApplicationCommandProps, command.ApplicationCommandResponse, GuildApplicationCommandAttributes, DiscordOpError>;
+export declare const handlers: {
+    list: () => Effect.Effect<never[], never, never>;
+    read: ({ olds, output }: {
+        olds: GuildApplicationCommandProps;
+        output: GuildApplicationCommandAttributes | undefined;
+    }) => Effect.Effect<GuildApplicationCommandAttributes | undefined, DiscordOpError, import("effect/unstable/http/HttpClient").HttpClient>;
+    diff: ({ news, output }: {
+        news: import("alchemy").Input<GuildApplicationCommandProps>;
+        output: GuildApplicationCommandAttributes | undefined;
+    }) => Effect.Effect<{
+        readonly action: 'update';
+    } | {
+        readonly action: 'noop';
+    } | undefined, DiscordOpError, import("effect/unstable/http/HttpClient").HttpClient>;
+    reconcile: ({ news }: {
+        news: GuildApplicationCommandProps;
+    }) => Effect.Effect<GuildApplicationCommandAttributes, DiscordOpError, import("effect/unstable/http/HttpClient").HttpClient>;
+    delete: ({ olds }: {
+        olds: GuildApplicationCommandProps;
+    }) => Effect.Effect<void, DiscordOpError, import("effect/unstable/http/HttpClient").HttpClient>;
+};
+export declare const DiscordGuildApplicationCommandProvider: () => import("effect/Layer").Layer<Provider.Provider<DiscordGuildApplicationCommand>, never, import("effect/unstable/http/HttpClient").HttpClient>;
+/**
+ * `guildApplicationCommand('ping', { applicationId, guildId, name: 'ping' })` — `adopt(true)`
+ *   piped on by default (H5). See the file header before pointing this at a guild Halibut manages.
+ */
+export declare const guildApplicationCommand: (id: string, props: GuildApplicationCommandProps) => Effect.Effect<DiscordGuildApplicationCommand, never, import("effect/unstable/http/HttpClient").HttpClient>;
+//# sourceMappingURL=guild-application-command.d.ts.map

package/dist/discord/guild-application-command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"guild-application-command.d.ts","sourceRoot":"","sources":["../../src/discord/guild-application-command.ts"],"names":[],"mappings":"AAkBA,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACnC,OAAO,KAAK,QAAQ,MAAM,kBAAkB,CAAC;AAC7C,OAAO,KAAK,OAAO,MAAM,kCAAkC,CAAC;AAC5D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mCAAmC,CAAC;AACxE,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,EACL,KAAK,aAAa,EAClB,KAAK,uBAAuB,EAI7B,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,mBAAmB,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAGtE,MAAM,WAAW,4BAA6B,SAAQ,aAAa;IACjE,gGAAgG;IAChG,aAAa,EAAE,MAAM,CAAC;IACtB,yEAAyE;IACzE,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,iCAAkC,SAAQ,uBAAuB;IAChF,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,EAAE,MAAM,CAAC;IACtB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,8BAA+B,SAAQ,QAAQ,CAC9D,iCAAiC,EACjC,4BAA4B,EAC5B,iCAAiC,EACjC,KAAK,EACL,mBAAmB,CACpB;CAAG;AAEJ,eAAO,MAAM,8BAA8B,iEAG1C,CAAC;AAEF,eAAO,MAAM,gCAAgC,UACpC,OAAO,KACb,KAAK,IAAI,8BAG8D,CAAC;AAc3E,6DAA6D;AAC7D,eAAO,MAAM,IAAI,EAAE,WAAW,CAC5B,4BAA4B,EAC5B,OAAO,CAAC,0BAA0B,EAClC,iCAAiC,EACjC,cAAc,CA6Bf,CAAC;AAEF,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;CAAwB,CAAC;AAE9C,eAAO,MAAM,sCAAsC,oJAIhD,CAAC;AAEJ;;;GAGG;AACH,eAAO,MAAM,uBAAuB,OAAQ,MAAM,SAAS,4BAA4B,+GAC1B,CAAC"}

package/dist/discord/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Discord providers for Alchemy.
+ *
+ * ⛔ THIS BARREL IS THE PUBLIC API, AND IT IS DELIBERATELY SMALLER THAN THE DIRECTORY. `resource.ts`
+ *   and `command-form.ts` are internals both resource files share — a consumer builds against the
+ *   two commands and `providers()`, not the engine underneath.
+ */
+export { applicationCommand, DiscordApplicationCommand, DiscordApplicationCommandProvider, isDiscordApplicationCommand, type ApplicationCommandAttributes, type ApplicationCommandProps, } from './application-command.ts';
+export { Credentials, CredentialsFromEnv, type DiscordCredentialsConfig, credentials, fromEnv, } from './credentials.ts';
+export { guildApplicationCommand, DiscordGuildApplicationCommand, DiscordGuildApplicationCommandProvider, isDiscordGuildApplicationCommand, type GuildApplicationCommandAttributes, type GuildApplicationCommandProps, } from './guild-application-command.ts';
+export { providers } from './providers.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/discord/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/discord/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,EACL,kBAAkB,EAClB,yBAAyB,EACzB,iCAAiC,EACjC,2BAA2B,EAC3B,KAAK,4BAA4B,EACjC,KAAK,uBAAuB,GAC7B,MAAM,0BAA0B,CAAC;AAClC,OAAO,EACL,WAAW,EACX,kBAAkB,EAClB,KAAK,wBAAwB,EAC7B,WAAW,EACX,OAAO,GACR,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EACL,uBAAuB,EACvB,8BAA8B,EAC9B,sCAAsC,EACtC,gCAAgC,EAChC,KAAK,iCAAiC,EACtC,KAAK,4BAA4B,GAClC,MAAM,gCAAgC,CAAC;AACxC,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/discord/index.js

@@ -0,0 +1,193 @@
+// src/discord/application-command.ts
+import { adopt } from "alchemy/AdoptPolicy";
+import { Resource } from "alchemy";
+import * as Provider from "alchemy/Provider";
+import * as command from "@distilled.cloud/discord/discord";
+import * as Effect2 from "effect/Effect";
+
+// src/discord/command-form.ts
+import { deepEqual } from "alchemy/Diff";
+var DEFAULT_TYPE = 1;
+var settled = (props) => ({
+  description: props.description ?? "",
+  nsfw: props.nsfw ?? false,
+  type: props.type ?? DEFAULT_TYPE
+});
+var commandBody = (props) => {
+  const fixed = settled(props);
+  const out = {
+    description: fixed.description,
+    name: props.name,
+    nsfw: fixed.nsfw,
+    type: fixed.type
+  };
+  if (props.options !== undefined)
+    out["options"] = props.options;
+  if (props.defaultMemberPermissions !== undefined) {
+    out["default_member_permissions"] = props.defaultMemberPermissions;
+  }
+  if (props.dmPermission !== undefined)
+    out["dm_permission"] = props.dmPermission;
+  if (props.contexts !== undefined)
+    out["contexts"] = props.contexts;
+  if (props.integrationTypes !== undefined)
+    out["integration_types"] = props.integrationTypes;
+  return out;
+};
+var commandMatches = (attributes, props) => {
+  const fixed = settled(props);
+  return attributes.name === props.name && attributes.description === fixed.description && attributes.nsfw === fixed.nsfw && attributes.type === fixed.type && (props.options === undefined || deepEqual(attributes.options, props.options)) && (props.defaultMemberPermissions === undefined || attributes.defaultMemberPermissions === props.defaultMemberPermissions) && (props.dmPermission === undefined || attributes.dmPermission === props.dmPermission) && (props.contexts === undefined || deepEqual(attributes.contexts, props.contexts)) && (props.integrationTypes === undefined || deepEqual(attributes.integrationTypes, props.integrationTypes));
+};
+var commandFieldsOf = (live) => ({
+  contexts: live.contexts ?? undefined,
+  defaultMemberPermissions: live.default_member_permissions ?? undefined,
+  description: live.description,
+  dmPermission: live.dm_permission,
+  integrationTypes: live.integration_types ?? undefined,
+  name: live.name,
+  nsfw: live.nsfw === true,
+  options: live.options ?? [],
+  type: live.type
+});
+
+// src/discord/resource.ts
+import { Unowned } from "alchemy/AdoptPolicy";
+import { isResolved } from "alchemy/Diff";
+import * as Effect from "effect/Effect";
+
+// src/discord/credentials.ts
+import { Credentials, CredentialsFromEnv, credentials } from "@distilled.cloud/discord/Credentials";
+var fromEnv = () => CredentialsFromEnv;
+
+// src/discord/resource.ts
+var discordOperations = (spec) => ({
+  read: ({ olds, output }) => Effect.gen(function* () {
+    const live = yield* spec.fetchByName(olds);
+    if (live === undefined)
+      return;
+    const attrs = spec.attributes(live);
+    if (output !== undefined)
+      return attrs;
+    return Unowned(attrs);
+  }),
+  diff: (news, output) => Effect.gen(function* () {
+    if (output === undefined || !isResolved(news))
+      return;
+    const live = yield* spec.fetchByName(news);
+    if (live === undefined)
+      return { action: "update" };
+    return spec.matches(spec.attributes(live), news) ? { action: "noop" } : { action: "update" };
+  }),
+  reconcile: (news) => Effect.gen(function* () {
+    const before = yield* spec.fetchByName(news);
+    if (before !== undefined && spec.matches(spec.attributes(before), news)) {
+      return spec.attributes(before);
+    }
+    const body = spec.upsertBody(news);
+    const after = yield* spec.upsert(news, body);
+    return spec.attributes(after);
+  }),
+  destroy: (olds) => Effect.gen(function* () {
+    const live = yield* spec.fetchByName(olds);
+    if (live === undefined)
+      return;
+    yield* spec.destroy(olds, live);
+  })
+});
+var discordHandlers = (spec) => {
+  const ops = discordOperations(spec);
+  const withCredentials = (effect) => Effect.provide(effect, CredentialsFromEnv);
+  return {
+    list: () => Effect.succeed([]),
+    read: ({ olds, output }) => withCredentials(ops.read({ olds, output })),
+    diff: ({ news, output }) => withCredentials(ops.diff(news, output)),
+    reconcile: ({ news }) => withCredentials(ops.reconcile(news)),
+    delete: ({ olds }) => withCredentials(ops.destroy(olds))
+  };
+};
+
+// src/discord/application-command.ts
+var DiscordApplicationCommand = Resource("Discord.ApplicationCommand", {
+  defaultRemovalPolicy: "retain"
+});
+var isDiscordApplicationCommand = (value) => typeof value === "object" && value !== null && value.Type === "Discord.ApplicationCommand";
+var attributesOf = (live) => ({
+  applicationId: live.application_id,
+  commandId: live.id,
+  version: live.version,
+  ...commandFieldsOf(live)
+});
+var spec = {
+  attributes: attributesOf,
+  describe: (props) => `applications/${props.applicationId}/commands ${props.name}`,
+  destroy: (props, live) => command.deleteApplicationCommand({ application_id: props.applicationId, command_id: live.id }),
+  fetchByName: (props) => command.listApplicationCommands({ application_id: props.applicationId }).pipe(Effect2.map((rows) => rows.find((row) => row.name === props.name))),
+  matches: commandMatches,
+  upsert: (props, body) => command.createApplicationCommand({
+    application_id: props.applicationId,
+    ...body
+  }),
+  upsertBody: commandBody
+};
+var handlers = discordHandlers(spec);
+var DiscordApplicationCommandProvider = () => Provider.effect(DiscordApplicationCommand, Effect2.succeed(DiscordApplicationCommand.Provider.of(handlers)));
+var applicationCommand = (id, props) => DiscordApplicationCommand(id, props).pipe(adopt(true));
+// src/discord/guild-application-command.ts
+import { adopt as adopt2 } from "alchemy/AdoptPolicy";
+import { Resource as Resource2 } from "alchemy";
+import * as Provider2 from "alchemy/Provider";
+import * as command2 from "@distilled.cloud/discord/discord";
+import * as Effect3 from "effect/Effect";
+var DiscordGuildApplicationCommand = Resource2("Discord.GuildApplicationCommand", { defaultRemovalPolicy: "retain" });
+var isDiscordGuildApplicationCommand = (value) => typeof value === "object" && value !== null && value.Type === "Discord.GuildApplicationCommand";
+var attributesOf2 = (live) => ({
+  applicationId: live.application_id,
+  commandId: live.id,
+  guildId: live.guild_id,
+  version: live.version,
+  ...commandFieldsOf(live)
+});
+var spec2 = {
+  attributes: attributesOf2,
+  describe: (props) => `applications/${props.applicationId}/guilds/${props.guildId}/commands ${props.name}`,
+  destroy: (props, live) => command2.deleteGuildApplicationCommand({
+    application_id: props.applicationId,
+    command_id: live.id,
+    guild_id: props.guildId
+  }),
+  fetchByName: (props) => command2.listGuildApplicationCommands({
+    application_id: props.applicationId,
+    guild_id: props.guildId
+  }).pipe(Effect3.map((rows) => rows.find((row) => row.name === props.name))),
+  matches: commandMatches,
+  upsert: (props, body) => command2.createGuildApplicationCommand({
+    application_id: props.applicationId,
+    guild_id: props.guildId,
+    ...body
+  }),
+  upsertBody: commandBody
+};
+var handlers2 = discordHandlers(spec2);
+var DiscordGuildApplicationCommandProvider = () => Provider2.effect(DiscordGuildApplicationCommand, Effect3.succeed(DiscordGuildApplicationCommand.Provider.of(handlers2)));
+var guildApplicationCommand = (id, props) => DiscordGuildApplicationCommand(id, props).pipe(adopt2(true));
+// src/discord/providers.ts
+import * as Layer from "effect/Layer";
+var providers = () => Layer.mergeAll(DiscordApplicationCommandProvider(), DiscordGuildApplicationCommandProvider());
+export {
+  Credentials,
+  CredentialsFromEnv,
+  DiscordApplicationCommand,
+  DiscordApplicationCommandProvider,
+  DiscordGuildApplicationCommand,
+  DiscordGuildApplicationCommandProvider,
+  applicationCommand,
+  credentials,
+  fromEnv,
+  guildApplicationCommand,
+  isDiscordApplicationCommand,
+  isDiscordGuildApplicationCommand,
+  providers
+};
+
+//# debugId=D2971C1C1AB4C81064756E2164756E21
+//# sourceMappingURL=index.js.map

package/dist/discord/index.js.map

@@ -0,0 +1,15 @@
+{
+  "version": 3,
+  "sources": ["../src/discord/application-command.ts", "../src/discord/command-form.ts", "../src/discord/resource.ts", "../src/discord/credentials.ts", "../src/discord/guild-application-command.ts", "../src/discord/providers.ts"],
+  "sourcesContent": [
+    "/**\n * `Discord.ApplicationCommand` — one GLOBAL slash/user/message command on a Discord application.\n *\n * ⛔ NOT WHAT `hf-discord-halibut.service` USES TODAY. Halibut registers guild-scoped commands\n *   only (`DISCORD_GUILD_ID` is always set in production — see `docs/discord.md#halibut`), so this\n *   resource has no live object to adopt yet. It exists because the distilled SDK, and Discord's\n *   own API, model global and guild commands as siblings (same shape, different scope), and a\n *   future bot or a future Halibut command that goes global needs it without a second family.\n *\n * ⚠️ GLOBAL COMMAND CHANGES TAKE UP TO AN HOUR TO PROPAGATE (Discord's own docs). A `diff` that\n *   ran right after a write could see stale results; this resource does not poll for propagation\n *   (S26 bounds waits at ~60s, an hour is not boundable), so a plan run inside that window may\n *   report drift that will resolve itself. Documented, not solved — see `docs/discord.md`.\n */\nimport { adopt } from 'alchemy/AdoptPolicy';\nimport { Resource } from 'alchemy';\nimport * as Provider from 'alchemy/Provider';\nimport * as command from '@distilled.cloud/discord/discord';\nimport type { DiscordOpError } from '@distilled.cloud/discord/Protocol';\nimport * as Effect from 'effect/Effect';\nimport {\n  type CommandFields,\n  type CommandFieldsAttributes,\n  commandBody,\n  commandFieldsOf,\n  commandMatches,\n} from './command-form.ts';\nimport type { DiscordRequirements, DiscordSpec } from './resource.ts';\nimport { discordHandlers } from './resource.ts';\n\nexport interface ApplicationCommandProps extends CommandFields {\n  /** The Discord application (bot) this command belongs to — a public snowflake, not a secret. */\n  applicationId: string;\n}\n\nexport interface ApplicationCommandAttributes extends CommandFieldsAttributes {\n  commandId: string;\n  applicationId: string;\n  version: string;\n}\n\nexport interface DiscordApplicationCommand extends Resource<\n  'Discord.ApplicationCommand',\n  ApplicationCommandProps,\n  ApplicationCommandAttributes,\n  never,\n  DiscordRequirements\n> {}\n\nexport const DiscordApplicationCommand = Resource<DiscordApplicationCommand>(\n  'Discord.ApplicationCommand',\n  {\n    // Commands are the thing a user reads; nothing here can be edited into another object.\n    defaultRemovalPolicy: 'retain',\n  },\n);\n\nexport const isDiscordApplicationCommand = (value: unknown): value is DiscordApplicationCommand =>\n  typeof value === 'object' &&\n  value !== null &&\n  (value as { Type?: unknown }).Type === 'Discord.ApplicationCommand';\n\nconst attributesOf = (live: command.ApplicationCommandResponse): ApplicationCommandAttributes => ({\n  applicationId: live.application_id,\n  commandId: live.id,\n  version: live.version,\n  ...commandFieldsOf(live),\n});\n\n/** Exported for direct testing against `fake-discord.ts` — the same seam `../netbox/prefix.ts` uses. */\nexport const spec: DiscordSpec<\n  ApplicationCommandProps,\n  command.ApplicationCommandResponse,\n  ApplicationCommandAttributes,\n  DiscordOpError\n> = {\n  attributes: attributesOf,\n  describe: (props) => `applications/${props.applicationId}/commands ${props.name}`,\n  destroy: (props, live) =>\n    command.deleteApplicationCommand({ application_id: props.applicationId, command_id: live.id }),\n  fetchByName: (props) =>\n    command\n      .listApplicationCommands({ application_id: props.applicationId })\n      .pipe(Effect.map((rows) => rows.find((row) => row.name === props.name))),\n  matches: commandMatches,\n  upsert: (props, body) =>\n    command.createApplicationCommand({\n      application_id: props.applicationId,\n      ...(body as Omit<command.CreateApplicationCommandRequest, 'application_id'>),\n    }),\n  upsertBody: commandBody,\n};\n\nexport const handlers = discordHandlers(spec);\n\nexport const DiscordApplicationCommandProvider = () =>\n  Provider.effect(\n    DiscordApplicationCommand,\n    Effect.succeed(DiscordApplicationCommand.Provider.of(handlers)),\n  );\n\n/**\n * `applicationCommand('help', { applicationId, name: 'help', description: '…' })` — `adopt(true)`\n *   piped on by default (H5), so a first deploy against a command that already exists silently\n *   takes it over instead of failing `OwnedBySomeoneElse`. Mirrors `cloudflare/website.ts`'s\n *   `astroWebsite`/`viteWebsite` convenience constructors.\n */\nexport const applicationCommand = (id: string, props: ApplicationCommandProps) =>\n  DiscordApplicationCommand(id, props).pipe(adopt(true));\n",
+    "/**\n * The wire body for a Discord command (global or guild), and the comparison that decides whether\n * it needs writing — shared by `application-command.ts` and `guild-application-command.ts` so the\n * two specs cannot drift on what \"matches\" means. Mirrors `../netbox/prefix-form.ts`: pure\n * functions of the props, extracted so a test can call them with a literal, no server involved.\n */\nimport { deepEqual } from 'alchemy/Diff';\n\n/** Fields every Discord command shares, independent of global vs. guild scope. */\nexport interface CommandFields {\n  readonly name: string;\n  readonly description?: string;\n  /**\n   * ⚠️ GAP: passed through opaquely, not re-modeled. The SDK's generated option union is ~40\n   *   nested schema types (subcommand, subcommand group, string/int/number/channel/role/user/\n   *   mentionable/attachment, each with its own choices and localizations) — see\n   *   `docs/upstream-conformance.md#discord`. A caller supplies the exact wire shape from\n   *   Discord's own docs; this resource neither validates nor transforms it.\n   */\n  readonly options?: readonly Record<string, unknown>[];\n  /** Bitfield, stringified, per Discord's real wire contract (the SDK types write as `number`). */\n  readonly defaultMemberPermissions?: string;\n  readonly dmPermission?: boolean;\n  readonly contexts?: readonly number[];\n  readonly integrationTypes?: readonly number[];\n  readonly nsfw?: boolean;\n  /** `ApplicationCommandType`; omitted means `1` (`CHAT_INPUT`), Discord's own default. */\n  readonly type?: number;\n}\n\nexport interface CommandFieldsAttributes {\n  readonly name: string;\n  readonly description: string;\n  readonly options: readonly Record<string, unknown>[];\n  readonly defaultMemberPermissions: string | undefined;\n  readonly dmPermission: boolean | undefined;\n  readonly contexts: readonly number[] | undefined;\n  readonly integrationTypes: readonly number[] | undefined;\n  readonly nsfw: boolean;\n  readonly type: number;\n}\n\nconst DEFAULT_TYPE = 1;\n\n/** The fields an undeclared prop still settles to, because Discord itself would. */\nconst settled = (props: CommandFields) => ({\n  description: props.description ?? '',\n  nsfw: props.nsfw ?? false,\n  type: props.type ?? DEFAULT_TYPE,\n});\n\n/**\n * ⛔ SENT IN FULL ON EVERY UPSERT, NEVER PARTIAL. Discord's create-as-upsert (resource.ts's own\n *   note) replaces the whole command, so a body that omitted a field the caller stopped declaring\n *   would never actually clear it — the same \"declared, then forgotten\" bug `prefix-form.ts`\n *   documents for NetBox's PATCH. Sending the full settled shape every time is what keeps a\n *   removed prop actually removed live, not just removed from the declaration.\n */\nexport const commandBody = (props: CommandFields): Record<string, unknown> => {\n  const fixed = settled(props);\n  const out: Record<string, unknown> = {\n    description: fixed.description,\n    name: props.name,\n    nsfw: fixed.nsfw,\n    type: fixed.type,\n  };\n  if (props.options !== undefined) out['options'] = props.options;\n  if (props.defaultMemberPermissions !== undefined) {\n    out['default_member_permissions'] = props.defaultMemberPermissions;\n  }\n  if (props.dmPermission !== undefined) out['dm_permission'] = props.dmPermission;\n  if (props.contexts !== undefined) out['contexts'] = props.contexts;\n  if (props.integrationTypes !== undefined) out['integration_types'] = props.integrationTypes;\n  return out;\n};\n\n/** Whether the live command already says what the declaration says. */\nexport const commandMatches = (\n  attributes: CommandFieldsAttributes,\n  props: CommandFields,\n): boolean => {\n  const fixed = settled(props);\n  return (\n    attributes.name === props.name &&\n    attributes.description === fixed.description &&\n    attributes.nsfw === fixed.nsfw &&\n    attributes.type === fixed.type &&\n    // ⛔ GATED LIKE EVERY OTHER OPTIONAL FIELD BELOW — an undeclared `options` means \"not mine\",\n    //   in both directions (this file's own header rule). An earlier version of this line\n    //   compared unconditionally against `props.options ?? []`: a declaration with no `options`\n    //   at all would then see live options as drift, `commandBody` (which already omits\n    //   `options` when undeclared) would upsert without it, and Discord's real full-replace\n    //   create would silently wipe a live command's arguments on the first non-dry-run deploy.\n    //   Caught in review before merge, not measured live.\n    (props.options === undefined || deepEqual(attributes.options, props.options)) &&\n    (props.defaultMemberPermissions === undefined ||\n      attributes.defaultMemberPermissions === props.defaultMemberPermissions) &&\n    (props.dmPermission === undefined || attributes.dmPermission === props.dmPermission) &&\n    (props.contexts === undefined || deepEqual(attributes.contexts, props.contexts)) &&\n    (props.integrationTypes === undefined ||\n      deepEqual(attributes.integrationTypes, props.integrationTypes))\n  );\n};\n\n/**\n * Reads the shared fields off any `ApplicationCommandResponse`-shaped object.\n *\n * ⚠️ `options` IS READ AS `readonly unknown[]`, NOT RE-TYPED. The SDK's real\n *   `ApplicationCommandResponseOptionsItem` union has no index signature (each option kind is a\n *   distinct generated interface), so it cannot structurally satisfy `Record<string, unknown>`\n *   without a cast — the same \"opaque passthrough\" gap `CommandFields.options` documents above.\n */\nexport const commandFieldsOf = (live: {\n  readonly name: string;\n  readonly description: string;\n  readonly options?: readonly unknown[] | null | undefined;\n  readonly default_member_permissions?: string | null | undefined;\n  readonly dm_permission?: boolean | undefined;\n  readonly contexts?: readonly number[] | null | undefined;\n  readonly integration_types?: readonly number[] | null | undefined;\n  readonly nsfw?: boolean | undefined;\n  readonly type: number;\n}): CommandFieldsAttributes => ({\n  contexts: live.contexts ?? undefined,\n  defaultMemberPermissions: live.default_member_permissions ?? undefined,\n  description: live.description,\n  dmPermission: live.dm_permission,\n  integrationTypes: live.integration_types ?? undefined,\n  name: live.name,\n  nsfw: live.nsfw === true,\n  options: (live.options as readonly Record<string, unknown>[] | null | undefined) ?? [],\n  type: live.type,\n});\n",
+    "/**\n * One shape for every Discord application-command object — global and guild-scoped alike.\n *\n * ⛔ THE ALTERNATIVE IS COPYING THE SAME READ/RECONCILE/DELETE PER RESOURCE. `application-command.ts`\n *   and `guild-application-command.ts` differ only in which distilled operations they call and\n *   whether `guild_id` is part of identity — so the read/diff/reconcile/delete flow lives here\n *   once, mirroring `../netbox/resource.ts`'s `netboxOperations`/`netboxHandlers` split.\n *\n * ★ UNLIKE NETBOX, THIS FOLLOWS UPSTREAM'S `Snippet.ts` READ/RECONCILE SHAPE EXACTLY (S7–S9), NOT\n *   netbox's \"adopt silently\" gap (H1). Discord commands carry no ownership marker of any kind —\n *   no tags, no metadata field a bot could stamp — so this is precisely the \"marker-less API\" S8\n *   describes, and `Snippet.ts@v2.0.0-beta.79#read` is the cited reference: an existing match is\n *   `Unowned(attrs)` on a cold read (no persisted `output`), and plain attributes on a warm read\n *   (persisted `output` says we already made or adopted this exact command). `adopt(true)` (H5),\n *   piped onto each resource by the constructors in the two resource files, is what turns that\n *   `Unowned` into a silent one-time takeover instead of an `OwnedBySomeoneElse` refusal.\n *\n * ★ RECONCILE IS ONE UPSERT CALL, LIKE `Snippet.ts`'s `putSnippet`. Discord's own docs for both\n *   Create Global/Guild Application Command say a command with the same name (and type) as an\n *   existing one OVERWRITES it — the create endpoint is a true upsert, not a create-only call that\n *   409s on a name collision. ⚠️ REASONED NOT MEASURED (no token available to this task; see\n *   `docs/discord.md`): this is Discord's documented behaviour, unchanged across API v10, but it\n *   has not been exercised against the real API by this change. One call therefore converges\n *   greenfield create, routine update AND adoption alike — there is no separate PATCH path, and\n *   S10's \"zero write calls when there is no drift\" is still honoured because `reconcile` skips\n *   the call entirely when `spec.matches` already holds.\n *\n * ⚠️ `list` ANSWERS EMPTY, ON PURPOSE, EVEN THOUGH THE DISTILLED LIST OPERATIONS EXIST. A bot's\n *   guild command set is exactly what `hf-discord-halibut.service` bulk-overwrites at every\n *   restart (see `docs/discord.md#halibut`); a `nuke` that enumerated and swept every live command\n *   would fight that ownership, not just this resource's own declarations. Adoption stays\n *   explicit, the same reasoning netbox's `list` gives for a shared instance predating the kit.\n */\nimport { Unowned } from 'alchemy/AdoptPolicy';\nimport { isResolved } from 'alchemy/Diff';\nimport type { Input } from 'alchemy/Input';\nimport type { DiscordOpContext } from '@distilled.cloud/discord/Protocol';\nimport * as Effect from 'effect/Effect';\nimport type * as HttpClient from 'effect/unstable/http/HttpClient';\nimport { CredentialsFromEnv } from './credentials.ts';\n\n/**\n * What every stack must still provide after `discordHandlers` bakes in `CredentialsFromEnv`\n * (below): the transport. `DiscordOpContext` is `Credentials | HttpClient.HttpClient`, so once\n * `Credentials` is supplied, `HttpClient.HttpClient` is what remains — mirroring\n * `../netbox/resource.ts#NetboxRequirements`.\n */\nexport type DiscordRequirements = HttpClient.HttpClient;\n\n/** Every Discord command resource's identity key, regardless of scope. */\nexport interface DiscordCommandIdentity {\n  readonly name: string;\n}\n\n/**\n * One Discord command object's distilled calls. `Live` is whatever the SDK decodes\n * (`ApplicationCommandResponse`); `E` is left to each resource file to declare, so a call site's\n * precise error union (in practice always `DiscordOpError` — see `protocol.ts` — because every\n * generated Discord operation shares one error channel) flows straight through.\n */\nexport type DiscordSpec<\n  Props extends DiscordCommandIdentity,\n  Live,\n  Attributes extends object,\n  E,\n> = {\n  /** Locate the live command by its declared name within this spec's scope (app, or app+guild). */\n  readonly fetchByName: (props: Props) => Effect.Effect<Live | undefined, E, DiscordOpContext>;\n  readonly attributes: (live: Live) => Attributes;\n  readonly matches: (attributes: Attributes, props: Props) => boolean;\n  readonly upsertBody: (props: Props) => Record<string, unknown>;\n  /** POST create-or-overwrite — see the upsert note above. */\n  readonly upsert: (\n    props: Props,\n    body: Record<string, unknown>,\n  ) => Effect.Effect<Live, E, DiscordOpContext>;\n  readonly destroy: (props: Props, live: Live) => Effect.Effect<unknown, E, DiscordOpContext>;\n  /** For error messages and test descriptions. */\n  readonly describe: (props: Props) => string;\n};\n\nexport const discordOperations = <\n  Props extends DiscordCommandIdentity,\n  Live,\n  Attributes extends object,\n  E,\n>(\n  spec: DiscordSpec<Props, Live, Attributes, E>,\n) => ({\n  read: ({ olds, output }: { olds: Props; output: Attributes | undefined }) =>\n    Effect.gen(function* () {\n      const live = yield* spec.fetchByName(olds);\n      if (live === undefined) return undefined;\n      const attrs = spec.attributes(live);\n      // Warm read: a prior apply already created or adopted this exact command — ours.\n      if (output !== undefined) return attrs;\n      // Cold read (fresh store, or state lost): no ownership marker exists on this vendor,\n      // so any match is `Unowned` until `adopt(true)` (or `--adopt`) says otherwise (S7, S8).\n      return Unowned(attrs);\n    }),\n\n  diff: (news: Input<Props>, output: Attributes | undefined) =>\n    Effect.gen(function* () {\n      if (output === undefined || !isResolved(news)) return undefined;\n      const live = yield* spec.fetchByName(news);\n      if (live === undefined) return { action: 'update' } as const;\n      return spec.matches(spec.attributes(live), news)\n        ? ({ action: 'noop' } as const)\n        : ({ action: 'update' } as const);\n    }),\n\n  reconcile: (news: Props) =>\n    Effect.gen(function* () {\n      const before = yield* spec.fetchByName(news);\n      if (before !== undefined && spec.matches(spec.attributes(before), news)) {\n        // Already exactly what is declared — S10: no write.\n        return spec.attributes(before);\n      }\n      const body = spec.upsertBody(news);\n      const after = yield* spec.upsert(news, body);\n      return spec.attributes(after);\n    }),\n\n  // ⚠️ GAP, NOT SOLVED: a TOCTOU race between the fetch above and the delete call below could\n  //   see Discord answer 404 on a command that vanished between the two — S11 asks that race to\n  //   be treated as success, `catchTag('NotFound', …)`. The SDK's declared error type for every\n  //   operation does not include `NotFound` (see `docs/discord.md#sdk-gaps` — measured, not\n  //   assumed), so there is no typed tag to catch here without an unsafe cast. Left unhandled.\n  destroy: (olds: Props) =>\n    Effect.gen(function* () {\n      const live = yield* spec.fetchByName(olds);\n      if (live === undefined) return;\n      yield* spec.destroy(olds, live);\n    }),\n});\n\n/**\n * The four provider handlers for a spec'd Discord command, wired once.\n *\n * ★ CREDENTIALS ARE PROVIDED HERE, ONCE. `CredentialsFromEnv` resolves `DISCORD_BOT_TOKEN` /\n *   `DISCORD_TOKEN` on the calling fiber per request (credentials.ts), so this closure keeps that\n *   laziness — nothing is captured at module load.\n */\nexport const discordHandlers = <\n  Props extends DiscordCommandIdentity,\n  Live,\n  Attributes extends object,\n  E,\n>(\n  spec: DiscordSpec<Props, Live, Attributes, E>,\n) => {\n  const ops = discordOperations(spec);\n  const withCredentials = <A>(effect: Effect.Effect<A, E, DiscordOpContext>) =>\n    Effect.provide(effect, CredentialsFromEnv);\n  return {\n    list: () => Effect.succeed([]),\n    read: ({ olds, output }: { olds: Props; output: Attributes | undefined }) =>\n      withCredentials(ops.read({ olds, output })),\n    diff: ({ news, output }: { news: Input<Props>; output: Attributes | undefined }) =>\n      withCredentials(ops.diff(news, output)),\n    reconcile: ({ news }: { news: Props }) => withCredentials(ops.reconcile(news)),\n    delete: ({ olds }: { olds: Props }) => withCredentials(ops.destroy(olds)),\n  };\n};\n",
+    "/**\n * Discord credentials — a bot token REFERENCE, resolved lazily (S24), never a prop.\n *\n * ⛔ NO TOKEN IS EVER A PROP OR AN ATTRIBUTE. Alchemy persists Attributes unencrypted\n *   (State/StateEncoding.ts@v2.0.0-beta.79#encodeState), so nothing a stack file holds may be a\n *   credential. `@distilled.cloud/discord/Credentials` already ships exactly the shape S24 asks\n *   for: `Credentials` is a lazy `Context.Service<Credentials, Effect.Effect<Config>>`, resolved\n *   on the calling fiber inside each operation (`DiscordProtocol`'s `credentials:` field), never\n *   at layer build. This file re-exports it rather than re-implementing it — the same choice\n *   `../netbox/resource.ts` made for `CredentialsFromEnv` — and adds only the house-specific\n *   naming and doc trail.\n *\n * ★ `CredentialsFromEnv` reads `DISCORD_BOT_TOKEN` (falling back to `DISCORD_TOKEN`) via Effect's\n *   `Config`, which is exactly the \"reference\" shape S25 asks for: the resource never sees the\n *   value, only the environment variable NAME is anywhere near a stack file, and the value itself\n *   is wrapped in `Redacted` the moment it is read.\n *\n * ⚠️ NO OpenBao MINT YET. H8's target (`Alchemy.Stack({ secrets })`) is unreleased (PR 1728, still\n *   on `main` only). Until the estate is on a release that carries it, the deploy process's own\n *   environment is the credential seam — a human or CI job exports `DISCORD_BOT_TOKEN` from\n *   wherever it mints it (on CT100 today: `/opt/homeflare/env/discord-halibut.env`, read by\n *   systemd's `EnvironmentFile=`, never by this package). This package never reads that file.\n */\nimport type { Config } from '@distilled.cloud/discord/Credentials';\nimport { Credentials, CredentialsFromEnv, credentials } from '@distilled.cloud/discord/Credentials';\n\n/** Re-exported so a consumer never has to reach into `@distilled.cloud/discord` by hand. */\nexport { Credentials, CredentialsFromEnv, credentials };\nexport type { Config as DiscordCredentialsConfig };\n\n/**\n * `DiscordCredentials.fromEnv()` — the layer every `discordProviders()` stack uses by default.\n * A thin, named alias over `CredentialsFromEnv` so a stack's import reads `Discord.*`\n * throughout, the way `../netbox/index.ts`'s barrel keeps `Netbox*` names at the front door.\n */\nexport const fromEnv = () => CredentialsFromEnv;\n",
+    "/**\n * `Discord.GuildApplicationCommand` — one guild-scoped slash/user/message command.\n *\n * 🔴 THIS IS WHAT `hf-discord-halibut.service` OWNS TODAY, AND DECLARING IT AGAINST HALIBUT'S OWN\n *   GUILDS WOULD FIGHT THE BOT, NOT REPLACE IT. Halibut calls `applySapphireGuildRegister()`\n *   before every login (`src/discord/register.ts` on CT100, `RegisterBehavior.BulkOverwrite`),\n *   which PUTs its exact `CURRENT_SLASH_NAMES` set on every restart. Deploying this resource\n *   against the same `(applicationId, guildId)` the bot manages means two owners converging the\n *   same object on two different schedules — the bot's restart would silently undo whatever this\n *   resource last wrote, and the next `alchemy plan` would then report drift the bot just caused,\n *   forever. See `docs/discord.md#halibut` for the measured command list, guild id source, and the\n *   handover sequence (freeze the list, adopt each command with `adopt(true)` for a verified\n *   no-op, THEN remove `applySapphireGuildRegister()` from the bot in the same deploy window —\n *   bot-runtime code, explicitly out of scope for this family).\n *\n * ★ Until that handover happens, this resource is for guilds/applications Halibut does not touch.\n */\nimport { adopt } from 'alchemy/AdoptPolicy';\nimport { Resource } from 'alchemy';\nimport * as Provider from 'alchemy/Provider';\nimport * as command from '@distilled.cloud/discord/discord';\nimport type { DiscordOpError } from '@distilled.cloud/discord/Protocol';\nimport * as Effect from 'effect/Effect';\nimport {\n  type CommandFields,\n  type CommandFieldsAttributes,\n  commandBody,\n  commandFieldsOf,\n  commandMatches,\n} from './command-form.ts';\nimport type { DiscordRequirements, DiscordSpec } from './resource.ts';\nimport { discordHandlers } from './resource.ts';\n\nexport interface GuildApplicationCommandProps extends CommandFields {\n  /** The Discord application (bot) this command belongs to — a public snowflake, not a secret. */\n  applicationId: string;\n  /** The guild (server) this command is scoped to — a public snowflake. */\n  guildId: string;\n}\n\nexport interface GuildApplicationCommandAttributes extends CommandFieldsAttributes {\n  commandId: string;\n  applicationId: string;\n  guildId: string;\n  version: string;\n}\n\nexport interface DiscordGuildApplicationCommand extends Resource<\n  'Discord.GuildApplicationCommand',\n  GuildApplicationCommandProps,\n  GuildApplicationCommandAttributes,\n  never,\n  DiscordRequirements\n> {}\n\nexport const DiscordGuildApplicationCommand = Resource<DiscordGuildApplicationCommand>(\n  'Discord.GuildApplicationCommand',\n  { defaultRemovalPolicy: 'retain' },\n);\n\nexport const isDiscordGuildApplicationCommand = (\n  value: unknown,\n): value is DiscordGuildApplicationCommand =>\n  typeof value === 'object' &&\n  value !== null &&\n  (value as { Type?: unknown }).Type === 'Discord.GuildApplicationCommand';\n\nconst attributesOf = (\n  live: command.ApplicationCommandResponse,\n): GuildApplicationCommandAttributes => ({\n  applicationId: live.application_id,\n  commandId: live.id,\n  // ⚠️ `guild_id` is present on every row a GUILD list call returns (Discord scopes the list by\n  //   guild), so this cast documents that guarantee rather than re-deriving it from `props`.\n  guildId: live.guild_id as string,\n  version: live.version,\n  ...commandFieldsOf(live),\n});\n\n/** Exported for direct testing against `fake-discord.ts`. */\nexport const spec: DiscordSpec<\n  GuildApplicationCommandProps,\n  command.ApplicationCommandResponse,\n  GuildApplicationCommandAttributes,\n  DiscordOpError\n> = {\n  attributes: attributesOf,\n  describe: (props) =>\n    `applications/${props.applicationId}/guilds/${props.guildId}/commands ${props.name}`,\n  destroy: (props, live) =>\n    command.deleteGuildApplicationCommand({\n      application_id: props.applicationId,\n      command_id: live.id,\n      guild_id: props.guildId,\n    }),\n  fetchByName: (props) =>\n    command\n      .listGuildApplicationCommands({\n        application_id: props.applicationId,\n        guild_id: props.guildId,\n      })\n      .pipe(Effect.map((rows) => rows.find((row) => row.name === props.name))),\n  matches: commandMatches,\n  upsert: (props, body) =>\n    command.createGuildApplicationCommand({\n      application_id: props.applicationId,\n      guild_id: props.guildId,\n      ...(body as Omit<\n        command.CreateGuildApplicationCommandRequest,\n        'application_id' | 'guild_id'\n      >),\n    }),\n  upsertBody: commandBody,\n};\n\nexport const handlers = discordHandlers(spec);\n\nexport const DiscordGuildApplicationCommandProvider = () =>\n  Provider.effect(\n    DiscordGuildApplicationCommand,\n    Effect.succeed(DiscordGuildApplicationCommand.Provider.of(handlers)),\n  );\n\n/**\n * `guildApplicationCommand('ping', { applicationId, guildId, name: 'ping' })` — `adopt(true)`\n *   piped on by default (H5). See the file header before pointing this at a guild Halibut manages.\n */\nexport const guildApplicationCommand = (id: string, props: GuildApplicationCommandProps) =>\n  DiscordGuildApplicationCommand(id, props).pipe(adopt(true));\n",
+    "/**\n * Both Discord command providers as one layer for a stack.\n *\n *     Layer.mergeAll(discordProviders(), …the stack's other providers)\n *       .pipe(Layer.provide(FetchHttpClient.layer))\n *\n * S16: a subpath's `providers()` plays the role upstream's own `Providers.ts` does — one minimal\n * insertion per family, requirements that never contain `unknown`. `FetchHttpClient.layer` is the\n * stack's own responsibility to provide (it is the shared transport every family needs, not\n * something a single vendor's `providers()` should pin), mirroring `../netbox/index.ts`'s barrel,\n * which exports `netboxHandlers` rather than a bundled transport too.\n */\nimport * as Layer from 'effect/Layer';\nimport { DiscordApplicationCommandProvider } from './application-command.ts';\nimport { DiscordGuildApplicationCommandProvider } from './guild-application-command.ts';\n\nexport const providers = () =>\n  Layer.mergeAll(DiscordApplicationCommandProvider(), DiscordGuildApplicationCommandProvider());\n"
+  ],
+  "mappings": "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",
+  "debugId": "D2971C1C1AB4C81064756E2164756E21",
+  "names": []
+}

package/dist/discord/providers.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Both Discord command providers as one layer for a stack.
+ *
+ *     Layer.mergeAll(discordProviders(), …the stack's other providers)
+ *       .pipe(Layer.provide(FetchHttpClient.layer))
+ *
+ * S16: a subpath's `providers()` plays the role upstream's own `Providers.ts` does — one minimal
+ * insertion per family, requirements that never contain `unknown`. `FetchHttpClient.layer` is the
+ * stack's own responsibility to provide (it is the shared transport every family needs, not
+ * something a single vendor's `providers()` should pin), mirroring `../netbox/index.ts`'s barrel,
+ * which exports `netboxHandlers` rather than a bundled transport too.
+ */
+import * as Layer from 'effect/Layer';
+export declare const providers: () => Layer.Layer<import("alchemy").Provider<import("./application-command.ts").DiscordApplicationCommand> | import("alchemy").Provider<import("./guild-application-command.ts").DiscordGuildApplicationCommand>, never, import("effect/unstable/http/HttpClient").HttpClient>;
+//# sourceMappingURL=providers.d.ts.map

package/dist/discord/providers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"providers.d.ts","sourceRoot":"","sources":["../../src/discord/providers.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AAItC,eAAO,MAAM,SAAS,gRACyE,CAAC"}