@wtfalch/foundry 0.1.0 → 0.2.0

package/dist/plan/providers-readers.js

@@ -1,15 +1,21 @@
 /**
- * A {@link ScopeResolver} backed by `AppliedState.serviceIds`
- * (`../state.ts`: "one id per service ... keyed by that service's own name
- * for the org") — the one place foundry records a provider's own id for an
- * org today, through the same `DeclaredOrgStore` seam #18 built.
+ * A {@link ScopeResolver} backed by `AppliedState.serviceIds` (`../state.ts`)
+ * — the one place foundry records a provider's own id for an org today,
+ * through the same `DeclaredOrgStore` seam #18 built.
  *
- * Nothing writes a `serviceIds[serviceKey]` entry yet — that is the
- * `StepExecutor` half of #20, not built here — so every resolver built this
- * way returns `null` for every org until it does. That is the correct
- * "nothing live yet" answer: a reader passed `null` returns `[]`, which
- * `computePlanDetail` (`diff.ts`) already reads as "no live resource",
- * exactly right for an org with no Coolify project (etc.) yet.
+ * `runSteps` (`plan-apply.ts`) now writes one `serviceIds` entry per
+ * resource it creates, keyed `system:kind:key` ({@link storeRecordedIds}
+ * below reads those back), and #20's `FoundryStepExecutor` (`executor.ts`)
+ * now also calls `StepExecutionContext.recordScopeId` for `coolify_project`,
+ * `zitadel_org` and `zitadel_project`, so a resolver built with one of those
+ * three `serviceKey`s returns the real id once that step has run. A
+ * Cloudflare zone is the one scope id nothing writes yet: `executor.ts`'s
+ * `cloudflareZone` records its result only under `cloudflare:zone:<domain>`
+ * (a resource id, read back by {@link storeRecordedIds}), not under a plain
+ * `cloudflare_zone` scope key — a resolver built with that `serviceKey`
+ * still returns `null` for every org. That is the correct "nothing live yet"
+ * answer: a reader passed `null` returns `[]`, which `computePlanDetail`
+ * (`diff.ts`) already reads as "no live resource".
  */
 export function storeScopeResolver(store, serviceKey) {
     return async (orgId) => {
@@ -20,6 +26,56 @@ export function storeScopeResolver(store, serviceKey) {
         return applied?.serviceIds[serviceKey] || null;
     };
 }
+export function storeRecordedIds(store, system) {
+    return async (orgId) => {
+        const applied = await store.getAppliedState(orgId);
+        const recorded = {};
+        if (!applied)
+            return recorded;
+        for (const [resourceKey, providerId] of Object.entries(applied.serviceIds)) {
+            const [keySystem, kind, ...rest] = resourceKey.split(':');
+            if (keySystem !== system || kind === undefined || rest.length === 0)
+                continue;
+            recorded[providerId] = `${kind}:${rest.join(':')}`;
+        }
+        return recorded;
+    };
+}
+/**
+ * Maps each live resource whose own id is one `recorded` names onto the
+ * foundry `kind`/`key` it was recorded under, keeping `config` exactly as
+ * the provider gave it (design doc, "Design for (1)": "the reader then maps
+ * each provider resource whose `key` equals a recorded provider id onto the
+ * recorded foundry `kind` and `key`"). A resource nothing recorded passes
+ * through unchanged, so `computePlanDetail` (`diff.ts`) still reports it
+ * unmanaged (#10) rather than this boundary guessing at a match.
+ *
+ * `dropUnrecordedKinds` names kinds that are dropped outright instead of
+ * passed through when unrecorded. Cloudflare's `tunnel` is the one case: a
+ * tunnel is account-wide, so an unrecorded one belongs to some other org,
+ * not this one, and every org's plan would otherwise report the same
+ * foreign tunnel as unmanaged.
+ */
+function applyRecordedIds(resources, recorded, dropUnrecordedKinds = new Set()) {
+    const mapped = [];
+    for (const resource of resources) {
+        const foundryKey = recorded[resource.key];
+        if (!foundryKey) {
+            if (!dropUnrecordedKinds.has(resource.kind))
+                mapped.push(resource);
+            continue;
+        }
+        const separator = foundryKey.indexOf(':');
+        mapped.push({
+            ...resource,
+            kind: foundryKey.slice(0, separator),
+            key: foundryKey.slice(separator + 1),
+        });
+    }
+    return mapped;
+}
+/** Cloudflare tunnels this org has not recorded are dropped — see {@link applyRecordedIds}. */
+const CLOUDFLARE_DROP_UNRECORDED = new Set(['tunnel']);
 /** `@wtfalch/providers`' own `LiveResource` (`resource.ts`) has no `system` field — foundry's adds it at this boundary. */
 function toFoundryResources(system, resources) {
     return resources.map((r) => ({ system, kind: r.kind, key: r.key, config: r.config }));
@@ -32,15 +88,21 @@ function toFoundryResources(system, resources) {
 export class ProvidersCoolifyReader {
     client;
     resolveScope;
-    constructor(client, resolveScope) {
+    resolveRecordedIds;
+    constructor(client, resolveScope, resolveRecordedIds) {
         this.client = client;
         this.resolveScope = resolveScope;
+        this.resolveRecordedIds = resolveRecordedIds;
     }
     async listResources(orgId) {
         const projectUuid = await this.resolveScope(orgId);
         if (!projectUuid)
             return [];
-        return toFoundryResources('coolify', await this.client.listResources(projectUuid));
+        const [resources, recorded] = await Promise.all([
+            this.client.listResources(projectUuid),
+            this.resolveRecordedIds(orgId),
+        ]);
+        return applyRecordedIds(toFoundryResources('coolify', resources), recorded);
     }
 }
 /**
@@ -51,15 +113,24 @@ export class ProvidersCoolifyReader {
 export class ProvidersCloudflareReader {
     client;
     resolveScope;
-    constructor(client, resolveScope) {
+    resolveRecordedIds;
+    constructor(client, resolveScope, resolveRecordedIds) {
         this.client = client;
         this.resolveScope = resolveScope;
+        this.resolveRecordedIds = resolveRecordedIds;
     }
     async listResources(orgId) {
         const zoneId = await this.resolveScope(orgId);
         if (!zoneId)
             return [];
-        return toFoundryResources('cloudflare', await this.client.listResources(zoneId));
+        const [resources, recorded] = await Promise.all([
+            this.client.listResources(zoneId),
+            this.resolveRecordedIds(orgId),
+        ]);
+        // A zone needs no mapping: its key is already the zone name, which is
+        // foundry's own zone key (`diff.ts`'s `planZone`), so it never matches a
+        // recorded provider id and always passes through unchanged.
+        return applyRecordedIds(toFoundryResources('cloudflare', resources), recorded, CLOUDFLARE_DROP_UNRECORDED);
     }
 }
 /**
@@ -70,14 +141,20 @@ export class ProvidersCloudflareReader {
 export class ProvidersZitadelReader {
     client;
     resolveScope;
-    constructor(client, resolveScope) {
+    resolveRecordedIds;
+    constructor(client, resolveScope, resolveRecordedIds) {
         this.client = client;
         this.resolveScope = resolveScope;
+        this.resolveRecordedIds = resolveRecordedIds;
     }
     async listResources(orgId) {
         const zitadelOrgId = await this.resolveScope(orgId);
         if (!zitadelOrgId)
             return [];
-        return toFoundryResources('zitadel', await this.client.listResources(zitadelOrgId));
+        const [resources, recorded] = await Promise.all([
+            this.client.listResources(zitadelOrgId),
+            this.resolveRecordedIds(orgId),
+        ]);
+        return applyRecordedIds(toFoundryResources('zitadel', resources), recorded);
     }
 }

package/dist/state.d.ts

@@ -34,17 +34,38 @@ export interface LastApplied {
 export interface AppliedState {
     orgId: OrgId;
     /**
-     * One id per service that takes jobs from many orgs (Files, AI,
-     * integrations — https://github.com/wtfalch/foundry/issues/14's resolved
-     * research #4) plus the per-org services (chat, mail), each keyed by that
-     * service's own name for the org.
+     * One id per resource `plan/plan-apply.ts`'s `runSteps` has made true,
+     * keyed `system:kind:key` — the same resource key `plan/diff.ts` plans
+     * against (e.g. `coolify:app:<orgId>`, `zitadel:app:<name>`), so two
+     * resources that share a `kind` (an org's several declared ZITADEL apps,
+     * #71) never overwrite each other's id the way a bare `kind` key did.
+     * `plan/providers-readers.ts`'s `storeRecordedIds` reads this map back to
+     * match a live provider resource to the foundry resource it was recorded
+     * for, instead of reporting it unmanaged (design:
+     * `.claude/campaign/2026-09-24-keys-and-memberships.md`, "Design for
+     * (1)").
+     *
+     * A provider *scope* id — `coolify_project`, `zitadel_org`,
+     * `zitadel_project`, a Cloudflare zone id (`plan/providers-readers.ts`'s
+     * `ScopeResolver`, https://github.com/wtfalch/foundry/issues/14's resolved
+     * research #4) — is a different id space and keeps its own plain key; a
+     * scope key has no `:` in it, so it can never collide with the
+     * `system:kind:key` form. `plan/executor.ts`'s `FoundryStepExecutor` is
+     * what writes these today, through `plan-apply.ts`'s
+     * `StepExecutionContext.recordScopeId` — backed by the very `serviceIds`
+     * map `runSteps` builds here and persists in one write at the end of a
+     * run, not a separate store write of its own (`StepExecutionContext`'s doc
+     * comment explains why: a second writer would race `runSteps`' own final
+     * one).
      */
     serviceIds: Record<string, string>;
     /** Checkpoints from the current or most recent apply. */
     checkpoints: Checkpoint[];
     /**
      * The name of every {@link DeclaredOrg} field the most recent apply could
-     * not make true, because nothing implements it yet.
+     * not make true: because nothing implements it yet, or because its step
+     * had not completed when the apply failed. `apply` recomputes it every
+     * time (#25), in `plan/plan-apply.ts`'s `failedFields`.
      *
      * Decision (#18): this field did not exist on the type this ticket found.
      * #7 ("Shape") and #18's "Done when" both require `apply` to "fail loudly

package/dist/store/postgres.d.ts

@@ -34,7 +34,9 @@ export declare class DeclaredOrgError extends Error {
  * on both `create` and `update`. #27 adds a third, narrower rule: storage and
  * AI spend limits are bigint-safe decimal strings of non-negative integers
  * (or `null` for uncapped), checked the same way on both `create` and the
- * merged result of `update`. The broader "combinations foundry knows are
+ * merged result of `update`. #67 adds a fourth (`org.ts`'s
+ * `validateBuyerIdentity`) and #71 a fifth (`org.ts`'s `validateHosting`),
+ * checked the same way. The broader "combinations foundry knows are
  * impossible are rejected with a reason" line needs a ruleset (domain
  * requirements per service, `adoptedApp.form`, mail-level transitions…)
  * that later tickets, not #18, #27 or #28, decide; `update` still merges and

package/dist/store/postgres.js

@@ -1,5 +1,5 @@
 import { eq, sql } from 'drizzle-orm';
-import { validateBuyerIdentity } from '../org.js';
+import { validateBuyerIdentity, validateHosting, validateOwner } from '../org.js';
 import { validateSlug } from '../slug.js';
 import { declaredOrgs, foundryAppliedState, } from './schema.js';
 const UNIQUE_VIOLATION = '23505';
@@ -50,6 +50,15 @@ function rowToOrg(row) {
         calls: { usesDomain: row.callsUsesDomain },
         issuer: { usesDomain: row.issuerUsesDomain },
         site: { enabled: row.siteEnabled, usesDomain: row.siteUsesDomain },
+        hosting: {
+            enabled: row.hostingEnabled,
+            usesDomain: row.hostingUsesDomain,
+            database: row.hostingDatabase,
+            tunnel: row.hostingTunnel,
+            gitBranch: row.hostingGitBranch,
+            buildPack: row.hostingBuildPack,
+            issuerApps: row.hostingIssuerApps,
+        },
         sso: { enabled: row.ssoEnabled },
         guests: { enabled: row.guestsEnabled },
         solo: { enabled: row.soloEnabled },
@@ -60,6 +69,8 @@ function rowToOrg(row) {
         adoptedApp: row.adoptedAppForm
             ? { form: row.adoptedAppForm }
             : null,
+        owner: rowToOwner(row),
+        test: row.isTest,
     };
 }
 function orgToRow(org) {
@@ -75,6 +86,13 @@ function orgToRow(org) {
         issuerUsesDomain: org.issuer.usesDomain,
         siteEnabled: org.site.enabled,
         siteUsesDomain: org.site.usesDomain,
+        hostingEnabled: org.hosting.enabled,
+        hostingUsesDomain: org.hosting.usesDomain,
+        hostingDatabase: org.hosting.database,
+        hostingTunnel: org.hosting.tunnel,
+        hostingGitBranch: org.hosting.gitBranch,
+        hostingBuildPack: org.hosting.buildPack,
+        hostingIssuerApps: org.hosting.issuerApps,
         ssoEnabled: org.sso.enabled,
         guestsEnabled: org.guests.enabled,
         soloEnabled: org.solo.enabled,
@@ -90,6 +108,10 @@ function orgToRow(org) {
         vatRegistered: org.buyer.vatRegistered,
         bespokeAppRepo: org.bespokeAppRepo,
         adoptedAppForm: org.adoptedApp?.form ?? null,
+        ownerEmail: org.owner?.email ?? null,
+        ownerGivenName: org.owner?.givenName ?? null,
+        ownerFamilyName: org.owner?.familyName ?? null,
+        isTest: org.test,
     };
 }
 /**
@@ -117,6 +139,17 @@ function rowToBuyer(row) {
         vatRegistered: row.vatRegistered,
     };
 }
+/**
+ * Reassembles `DeclaredOrg.owner` from the row's three separate nullable
+ * columns -- present only when all three are, same "all parts or none"
+ * pattern {@link rowToBuyer} uses for the buyer's address.
+ */
+function rowToOwner(row) {
+    const { ownerEmail, ownerGivenName, ownerFamilyName } = row;
+    if (ownerEmail === null || ownerGivenName === null || ownerFamilyName === null)
+        return null;
+    return { email: ownerEmail, givenName: ownerGivenName, familyName: ownerFamilyName };
+}
 /**
  * `DeclaredOrgStore` (`../store.ts`) on Postgres, for #18: create, read and
  * edit a {@link DeclaredOrg}, and read and write the {@link AppliedState}
@@ -129,7 +162,9 @@ function rowToBuyer(row) {
  * on both `create` and `update`. #27 adds a third, narrower rule: storage and
  * AI spend limits are bigint-safe decimal strings of non-negative integers
  * (or `null` for uncapped), checked the same way on both `create` and the
- * merged result of `update`. The broader "combinations foundry knows are
+ * merged result of `update`. #67 adds a fourth (`org.ts`'s
+ * `validateBuyerIdentity`) and #71 a fifth (`org.ts`'s `validateHosting`),
+ * checked the same way. The broader "combinations foundry knows are
  * impossible are rejected with a reason" line needs a ruleset (domain
  * requirements per service, `adoptedApp.form`, mail-level transitions…)
  * that later tickets, not #18, #27 or #28, decide; `update` still merges and
@@ -169,11 +204,27 @@ export function createPostgresDeclaredOrgStore(db) {
         if (reason)
             throw new DeclaredOrgError(`buyer identity invalid: ${reason} (#67)`);
     }
+    // #71: same place `requireValidBuyer` checks the buyer identity (#67), on
+    // both `create` and the merged result of `update`.
+    function requireValidHosting(org) {
+        const reason = validateHosting(org.hosting);
+        if (reason)
+            throw new DeclaredOrgError(`hosting invalid: ${reason} (#71)`);
+    }
+    // Same place `requireValidHosting` checks hosting, on both `create` and
+    // the merged result of `update`.
+    function requireValidOwner(org) {
+        const reason = validateOwner(org.owner);
+        if (reason)
+            throw new DeclaredOrgError(`owner invalid: ${reason}`);
+    }
     return {
         async create(org) {
             requireValidSlug(org.slug);
             requireValidLimits(org);
             requireValidBuyer(org);
+            requireValidHosting(org);
+            requireValidOwner(org);
             try {
                 await db.insert(declaredOrgs).values(orgToRow(org));
             }
@@ -212,6 +263,8 @@ export function createPostgresDeclaredOrgStore(db) {
             const next = { ...current, ...patch, id: current.id };
             requireValidLimits(next);
             requireValidBuyer(next);
+            requireValidHosting(next);
+            requireValidOwner(next);
             try {
                 await db
                     .update(declaredOrgs)
@@ -263,5 +316,15 @@ export function createPostgresDeclaredOrgStore(db) {
                 .values(values)
                 .onConflictDoUpdate({ target: foundryAppliedState.orgId, set: values });
         },
+        async delete(id) {
+            // Applied state first: `0002_applied_state.sql`'s
+            // `foundry_applied_state_org_fkey` references the declared org with no
+            // cascade, so deleting the org first would fail while its applied
+            // state row still points at it. Both deletes are no-ops (idempotent)
+            // when the row is already gone, matching this method's own doc
+            // comment on `../store.ts`.
+            await db.delete(foundryAppliedState).where(eq(foundryAppliedState.orgId, id));
+            await db.delete(declaredOrgs).where(eq(declaredOrgs.id, id));
+        },
     };
 }

package/dist/store/schema.d.ts

@@ -1,3 +1,4 @@
+import type { IssuerApp } from '../org.js';
 import type { Checkpoint } from '../state.js';
 /**
  * Mirrors `migrations/0001_declared_org.sql`, which is the source of truth:
@@ -196,6 +197,127 @@ export declare const declaredOrgs: import("drizzle-orm/pg-core").PgTableWithColu
             identity: undefined;
             generated: undefined;
         }, {}, {}>;
+        hostingEnabled: import("drizzle-orm/pg-core").PgColumn<{
+            name: "hosting_enabled";
+            tableName: "foundry_declared_orgs";
+            dataType: "boolean";
+            columnType: "PgBoolean";
+            data: boolean;
+            driverParam: boolean;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        hostingUsesDomain: import("drizzle-orm/pg-core").PgColumn<{
+            name: "hosting_uses_domain";
+            tableName: "foundry_declared_orgs";
+            dataType: "boolean";
+            columnType: "PgBoolean";
+            data: boolean;
+            driverParam: boolean;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        hostingDatabase: import("drizzle-orm/pg-core").PgColumn<{
+            name: "hosting_database";
+            tableName: "foundry_declared_orgs";
+            dataType: "boolean";
+            columnType: "PgBoolean";
+            data: boolean;
+            driverParam: boolean;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        hostingTunnel: import("drizzle-orm/pg-core").PgColumn<{
+            name: "hosting_tunnel";
+            tableName: "foundry_declared_orgs";
+            dataType: "boolean";
+            columnType: "PgBoolean";
+            data: boolean;
+            driverParam: boolean;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        hostingGitBranch: import("drizzle-orm/pg-core").PgColumn<{
+            name: "hosting_git_branch";
+            tableName: "foundry_declared_orgs";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        hostingBuildPack: import("drizzle-orm/pg-core").PgColumn<{
+            name: "hosting_build_pack";
+            tableName: "foundry_declared_orgs";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        hostingIssuerApps: import("drizzle-orm/pg-core").PgColumn<{
+            name: "hosting_issuer_apps";
+            tableName: "foundry_declared_orgs";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: IssuerApp[];
+            driverParam: unknown;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: IssuerApp[];
+        }>;
         ssoEnabled: import("drizzle-orm/pg-core").PgColumn<{
             name: "sso_enabled";
             tableName: "foundry_declared_orgs";
@@ -451,6 +573,74 @@ export declare const declaredOrgs: import("drizzle-orm/pg-core").PgTableWithColu
             identity: undefined;
             generated: undefined;
         }, {}, {}>;
+        ownerEmail: import("drizzle-orm/pg-core").PgColumn<{
+            name: "owner_email";
+            tableName: "foundry_declared_orgs";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        ownerGivenName: import("drizzle-orm/pg-core").PgColumn<{
+            name: "owner_given_name";
+            tableName: "foundry_declared_orgs";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        ownerFamilyName: import("drizzle-orm/pg-core").PgColumn<{
+            name: "owner_family_name";
+            tableName: "foundry_declared_orgs";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        isTest: import("drizzle-orm/pg-core").PgColumn<{
+            name: "is_test";
+            tableName: "foundry_declared_orgs";
+            dataType: "boolean";
+            columnType: "PgBoolean";
+            data: boolean;
+            driverParam: boolean;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
         createdAt: import("drizzle-orm/pg-core").PgColumn<{
             name: "created_at";
             tableName: "foundry_declared_orgs";

package/dist/store/schema.js

@@ -18,6 +18,14 @@ export const declaredOrgs = pgTable('foundry_declared_orgs', {
     // SiteConfig (org.ts, T10). A brand new org has no cms site.
     siteEnabled: boolean('site_enabled').notNull().default(false),
     siteUsesDomain: boolean('site_uses_domain').notNull().default(false),
+    // HostingConfig (org.ts, #71). A brand new org has no hosted app.
+    hostingEnabled: boolean('hosting_enabled').notNull().default(false),
+    hostingUsesDomain: boolean('hosting_uses_domain').notNull().default(false),
+    hostingDatabase: boolean('hosting_database').notNull().default(false),
+    hostingTunnel: boolean('hosting_tunnel').notNull().default(false),
+    hostingGitBranch: text('hosting_git_branch').notNull().default('main'),
+    hostingBuildPack: text('hosting_build_pack').notNull().default('nixpacks'),
+    hostingIssuerApps: jsonb('hosting_issuer_apps').notNull().default([]).$type(),
     ssoEnabled: boolean('sso_enabled').notNull().default(false),
     guestsEnabled: boolean('guests_enabled').notNull().default(false),
     soloEnabled: boolean('solo_enabled').notNull().default(false),
@@ -40,6 +48,16 @@ export const declaredOrgs = pgTable('foundry_declared_orgs', {
     vatRegistered: boolean('vat_registered'),
     bespokeAppRepo: text('bespoke_app_repo'),
     adoptedAppForm: text('adopted_app_form'),
+    // OwnerIdentity (org.ts): the org's owner, invited by ZITADEL email. All
+    // three nullable -- a brand new org has none of them, reassembled as one
+    // object only once all three are non-null (same shape as BuyerIdentity's
+    // own contact fields above).
+    ownerEmail: text('owner_email'),
+    ownerGivenName: text('owner_given_name'),
+    ownerFamilyName: text('owner_family_name'),
+    // `test: boolean` (org.ts): only a test org can be destroyed. A brand new
+    // org defaults to real (false).
+    isTest: boolean('is_test').notNull().default(false),
     createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
     updatedAt: timestamp('updated_at', { withTimezone: true }).notNull().defaultNow(),
 });

package/dist/store.d.ts

@@ -20,4 +20,14 @@ export interface DeclaredOrgStore {
     update(id: OrgId, patch: Partial<DeclaredOrg>): Promise<DeclaredOrg>;
     getAppliedState(id: OrgId): Promise<AppliedState | null>;
     putAppliedState(state: AppliedState): Promise<void>;
+    /**
+     * Removes the declared org and its applied state together. Called only by
+     * `FoundryPlanApply.destroy` (`plan/plan-apply.ts`), once every resource it
+     * recorded for this org has already been deleted from Coolify, Cloudflare
+     * and ZITADEL -- this is the last step, not the first. Idempotent: deleting
+     * an id that does not exist (or no longer has applied state) is a no-op,
+     * not an error, so a retried destroy that reaches this step twice never
+     * throws.
+     */
+    delete(id: OrgId): Promise<void>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wtfalch/foundry",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Foundry's SDK: the declared org's types, the plan and apply contracts, and the state store's interface.",
   "repository": {
     "type": "git",
@@ -9,9 +9,7 @@
   },
   "license": "MIT",
   "type": "module",
-  "files": [
-    "dist"
-  ],
+  "files": ["dist"],
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
@@ -27,11 +25,16 @@
   "engines": {
     "node": ">=22.0.0"
   },
+  "scripts": {
+    "build": "rm -rf dist && tsc -p tsconfig.build.json && mkdir -p dist/migrations && find src/migrations -maxdepth 1 -name '*.sql' -exec cp {} dist/migrations/ \\;",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run"
+  },
   "peerDependencies": {
     "drizzle-orm": ">=0.45.2"
   },
   "dependencies": {
-    "@wtfalch/providers": "0.1.0"
+    "@wtfalch/providers": "0.5.0"
   },
   "devDependencies": {
     "@electric-sql/pglite": "^0.5.8",
@@ -40,10 +43,5 @@
     "postgres": "3.4.9",
     "typescript": "^5.9.0",
     "vitest": "^4.1.6"
-  },
-  "scripts": {
-    "build": "rm -rf dist && tsc -p tsconfig.build.json && mkdir -p dist/migrations && find src/migrations -maxdepth 1 -name '*.sql' -exec cp {} dist/migrations/ \\;",
-    "typecheck": "tsc --noEmit",
-    "test": "vitest run"
   }
-}
+}