@ashlr/stack-core 0.1.1 → 0.3.0

package/src/__tests__/config-own-services.test.ts

@@ -0,0 +1,183 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { parse as parseToml, stringify as stringifyToml } from "smol-toml";
+import {
+  CONFIG_FILENAME,
+  LOCAL_FILENAME,
+  type ServiceEntry,
+  emptyConfig,
+  readConfig,
+  writeConfig,
+} from "../config.ts";
+
+const SERVICE_NAMES = ["__proto__", "constructor", "toString", "github"];
+const ENTRY: ServiceEntry = {
+  provider: "github",
+  secrets: ["FIXTURE_TOKEN_SLOT"],
+  mcp: "fixture-mcp",
+  resource_id: "fixture-resource",
+  region: "fixture-region",
+  meta: { account: "fixture-local-account" },
+  created_at: "2026-10-14T00:00:00Z",
+  created_by: "fixture-user",
+};
+
+function expectOwnService(
+  services: Record<string, ServiceEntry>,
+  name: string,
+  entry: ServiceEntry,
+): void {
+  expect(Object.getPrototypeOf(services)).toBe(Object.prototype);
+  expect(Object.hasOwn(services, name)).toBe(true);
+  expect(Object.keys(services)).toEqual([name]);
+  expect(services[name]).toEqual(entry);
+  expect(JSON.parse(JSON.stringify(services))).toEqual(Object.fromEntries([[name, entry]]));
+}
+
+describe("service names remain own configuration data", () => {
+  let root: string;
+  let cwd: string;
+  let registryDir: string;
+  let previousRegistryDir: string | undefined;
+
+  beforeEach(() => {
+    root = mkdtempSync(join(tmpdir(), "stack-own-services-"));
+    cwd = join(root, "project");
+    registryDir = join(root, "registry");
+    mkdirSync(cwd);
+    previousRegistryDir = process.env.STACK_REGISTRY_DIR;
+    process.env.STACK_REGISTRY_DIR = registryDir;
+  });
+
+  afterEach(() => {
+    if (previousRegistryDir === undefined)
+      Reflect.deleteProperty(process.env, "STACK_REGISTRY_DIR");
+    else process.env.STACK_REGISTRY_DIR = previousRegistryDir;
+    rmSync(root, { recursive: true, force: true });
+  });
+
+  test.each(SERVICE_NAMES)("reads split files without losing the %s service", async (name) => {
+    writeFileSync(
+      join(cwd, CONFIG_FILENAME),
+      stringifyToml({
+        stack: { version: "1" },
+        services: Object.fromEntries([
+          [
+            name,
+            {
+              provider: ENTRY.provider,
+              secrets: ENTRY.secrets,
+              mcp: ENTRY.mcp,
+            },
+          ],
+        ]),
+      }),
+    );
+    writeFileSync(
+      join(cwd, LOCAL_FILENAME),
+      stringifyToml({
+        stack: { project_id: "stk_fixture" },
+        services: Object.fromEntries([
+          [
+            name,
+            {
+              resource_id: ENTRY.resource_id,
+              region: ENTRY.region,
+              meta: ENTRY.meta,
+              created_at: ENTRY.created_at,
+              created_by: ENTRY.created_by,
+            },
+          ],
+        ]),
+      }),
+    );
+
+    const config = await readConfig(cwd);
+
+    expect(config.stack.project_id).toBe("stk_fixture");
+    expectOwnService(config.services, name, ENTRY);
+  });
+
+  test.each(SERVICE_NAMES)("keeps %s when no local service entry exists", async (name) => {
+    writeFileSync(
+      join(cwd, CONFIG_FILENAME),
+      stringifyToml({
+        stack: { version: "1" },
+        services: Object.fromEntries([
+          [name, { provider: ENTRY.provider, secrets: ENTRY.secrets }],
+        ]),
+      }),
+    );
+    writeFileSync(
+      join(cwd, LOCAL_FILENAME),
+      stringifyToml({
+        stack: { project_id: "stk_fixture" },
+        services: {},
+      }),
+    );
+
+    const config = await readConfig(cwd);
+
+    expectOwnService(config.services, name, {
+      provider: ENTRY.provider,
+      secrets: ENTRY.secrets,
+      created_at: "1970-01-01T00:00:00Z",
+    });
+  });
+
+  test.each(SERVICE_NAMES)(
+    "writes and registers %s while keeping instance fields local",
+    async (name) => {
+      const original = emptyConfig("fixture-template");
+      original.services = Object.fromEntries([[name, ENTRY]]);
+
+      await writeConfig(original, cwd);
+
+      const shapeText = readFileSync(join(cwd, CONFIG_FILENAME), "utf8");
+      const shape = parseToml(shapeText);
+      const local = parseToml(readFileSync(join(cwd, LOCAL_FILENAME), "utf8"));
+      expect(Object.hasOwn(shape.services as object, name)).toBe(true);
+      expect(Object.hasOwn(local.services as object, name)).toBe(true);
+      expect((shape.services as Record<string, unknown>)[name]).toEqual({
+        provider: ENTRY.provider,
+        secrets: ENTRY.secrets,
+        mcp: ENTRY.mcp,
+      });
+      expect((local.services as Record<string, unknown>)[name]).toEqual({
+        resource_id: ENTRY.resource_id,
+        region: ENTRY.region,
+        meta: ENTRY.meta,
+        created_at: ENTRY.created_at,
+        created_by: ENTRY.created_by,
+      });
+      expect(shapeText).not.toContain(ENTRY.resource_id!);
+      expect(shapeText).not.toContain("fixture-local-account");
+      expect(shapeText).not.toContain(original.stack.project_id);
+      expectOwnService((await readConfig(cwd)).services, name, ENTRY);
+      const registry = JSON.parse(readFileSync(join(registryDir, "projects.json"), "utf8"));
+      expect(registry.projects[0].services).toEqual([name]);
+    },
+  );
+
+  test.each(SERVICE_NAMES)("migrates a legacy %s service without losing it", async (name) => {
+    writeFileSync(
+      join(cwd, CONFIG_FILENAME),
+      stringifyToml({
+        stack: { version: "1", project_id: "stk_legacy_fixture" },
+        services: Object.fromEntries([[name, ENTRY]]),
+      }),
+    );
+
+    const legacy = await readConfig(cwd);
+    expectOwnService(legacy.services, name, ENTRY);
+    expect(existsSync(join(cwd, LOCAL_FILENAME))).toBe(false);
+
+    await writeConfig(legacy, cwd);
+
+    const roundTrip = await readConfig(cwd);
+    expect(roundTrip.stack.project_id).toBe("stk_legacy_fixture");
+    expectOwnService(roundTrip.services, name, ENTRY);
+  });
+});

package/src/__tests__/config-split.test.ts

@@ -1,11 +1,13 @@
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import { mkdtempSync, readFileSync, writeFileSync, existsSync } from "node:fs";
+import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
+import { parse as parseToml } from "smol-toml";
 import {
   CONFIG_FILENAME,
   LOCAL_FILENAME,
   emptyConfig,
+  getService,
   readConfig,
   writeConfig,
 } from "../config.ts";
@@ -22,7 +24,8 @@ describe("committed + local config split", () => {
   });
 
   afterEach(() => {
-    if (previousRegistryDir === undefined) delete process.env.STACK_REGISTRY_DIR;
+    if (previousRegistryDir === undefined)
+      Reflect.deleteProperty(process.env, "STACK_REGISTRY_DIR");
     else process.env.STACK_REGISTRY_DIR = previousRegistryDir;
   });
 
@@ -70,6 +73,71 @@ describe("committed + local config split", () => {
     expect(roundtrip.services.supabase.secrets).toEqual(["FOO"]);
   });
 
+  test("round-trips a service name containing a hyphen through both files", async () => {
+    const original = emptyConfig("fixture-template");
+    original.services["fixture-api"] = {
+      provider: "neon",
+      resource_id: "hyphen-resource",
+      region: "us-east-1",
+      secrets: ["FIXTURE_API_URL", "FIXTURE_API_KEY"],
+      mcp: "fixture-api",
+      meta: { endpoint: "fixture-endpoint" },
+      created_at: "2026-10-30T00:00:00Z",
+      created_by: "test",
+    };
+    await writeConfig(original, cwd);
+
+    const shape = parseToml(readFileSync(join(cwd, CONFIG_FILENAME), "utf-8"));
+    const local = parseToml(readFileSync(join(cwd, LOCAL_FILENAME), "utf-8"));
+    expect(Object.keys(shape.services as object)).toEqual(["fixture-api"]);
+    expect(Object.keys(local.services as object)).toEqual(["fixture-api"]);
+    expect(shape.services).toEqual({
+      "fixture-api": {
+        provider: "neon",
+        secrets: ["FIXTURE_API_URL", "FIXTURE_API_KEY"],
+        mcp: "fixture-api",
+      },
+    });
+    expect(local.services).toEqual({
+      "fixture-api": {
+        resource_id: "hyphen-resource",
+        region: "us-east-1",
+        meta: { endpoint: "fixture-endpoint" },
+        created_at: "2026-10-30T00:00:00Z",
+        created_by: "test",
+      },
+    });
+
+    const merged = await readConfig(cwd);
+    expect(Object.keys(merged.services)).toEqual(["fixture-api"]);
+    expect(getService(merged, "fixture-api")).toEqual(original.services["fixture-api"]);
+  });
+
+  test("legacy file with a hyphenated service name migrates without losing it", async () => {
+    const legacy = `
+[stack]
+version = "1"
+project_id = "stk_hyphen"
+
+[services.fixture-api]
+provider = "neon"
+resource_id = "hyphen-legacy"
+secrets = ["X"]
+created_at = "2026-04-17T00:00:00Z"
+`.trim();
+    writeFileSync(join(cwd, CONFIG_FILENAME), legacy);
+    const config = await readConfig(cwd);
+    expect(Object.keys(config.services)).toEqual(["fixture-api"]);
+    expect(config.services["fixture-api"].resource_id).toBe("hyphen-legacy");
+
+    await writeConfig(config, cwd);
+    const shape = readFileSync(join(cwd, CONFIG_FILENAME), "utf-8");
+    expect(shape).toContain("fixture-api");
+    expect(shape).not.toContain("hyphen-legacy");
+    const roundTrip = await readConfig(cwd);
+    expect(roundTrip.services["fixture-api"]).toEqual(config.services["fixture-api"]);
+  });
+
   test("writeConfig auto-appends .stack.local.toml to .gitignore", async () => {
     await writeConfig(emptyConfig(), cwd);
     const gitignore = readFileSync(join(cwd, ".gitignore"), "utf-8");
@@ -136,3 +204,205 @@ default = true
     expect(shape).toContain("OPENAI_API_KEY");
   });
 });
+
+describe("public config reference matches produced data", () => {
+  let cwd: string;
+  let registry: string;
+  let previousRegistryDir: string | undefined;
+
+  beforeEach(() => {
+    cwd = mkdtempSync(join(tmpdir(), "stack-schema-config-"));
+    registry = mkdtempSync(join(tmpdir(), "stack-schema-registry-"));
+    previousRegistryDir = process.env.STACK_REGISTRY_DIR;
+    process.env.STACK_REGISTRY_DIR = registry;
+  });
+
+  afterEach(() => {
+    if (previousRegistryDir === undefined)
+      Reflect.deleteProperty(process.env, "STACK_REGISTRY_DIR");
+    else process.env.STACK_REGISTRY_DIR = previousRegistryDir;
+    rmSync(cwd, { recursive: true, force: true });
+    rmSync(registry, { recursive: true, force: true });
+  });
+
+  function reference() {
+    return JSON.parse(
+      readFileSync(new URL("../../../site/public/openapi.json", import.meta.url), "utf-8"),
+    ).components.schemas;
+  }
+
+  // These are field-coverage checks on actual serialized/merged values, not a
+  // JSON Schema validator or a claim that readConfig validates arbitrary input.
+  function expectDocumentedFields(
+    value: object,
+    schema: { properties: object; required?: string[] },
+  ) {
+    for (const key of Object.keys(value)) expect(schema.properties).toHaveProperty(key);
+    for (const key of schema.required ?? []) expect(value).toHaveProperty(key);
+  }
+
+  function expectTable(value: unknown): asserts value is Record<string, unknown> {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+      throw new Error("Expected a parsed TOML table in the synthetic config fixture.");
+    }
+  }
+
+  test("StackToml describes the parsed committed output of a blank write", async () => {
+    await writeConfig(emptyConfig(), cwd);
+    const shape = parseToml(readFileSync(join(cwd, CONFIG_FILENAME), "utf-8"));
+    const schema = reference().StackToml;
+
+    expectDocumentedFields(shape, schema);
+    expect(Object.keys(shape)).toEqual(["stack", "services", "environments"]);
+    expect(schema.required).toEqual(Object.keys(shape));
+    expect(schema.properties.stack.properties.version.type).toBe("string");
+    expect(schema.properties).not.toHaveProperty("version");
+    expect(schema.properties).not.toHaveProperty("project");
+    expect(shape.stack).toEqual({ version: "1" });
+    expect(shape.services).toEqual({});
+    expect(shape.environments).toEqual([{ name: "dev", default: true }]);
+  });
+
+  test("committed service fields stay separate from the full merged ServiceEntry", async () => {
+    const config = emptyConfig("fixture-template");
+    const metadata = { note: "synthetic metadata", nested: { enabled: true } };
+    config.services.primary = {
+      provider: "supabase",
+      resource_id: "fixture-resource",
+      region: "fixture-region",
+      secrets: ["FIXTURE_URL"],
+      mcp: "fixture-mcp",
+      meta: metadata,
+      created_at: "fixture-time",
+      created_by: "fixture-owner",
+    };
+    await writeConfig(config, cwd);
+    const shape = parseToml(readFileSync(join(cwd, CONFIG_FILENAME), "utf-8"));
+    const local = parseToml(readFileSync(join(cwd, LOCAL_FILENAME), "utf-8"));
+    const merged = await readConfig(cwd);
+    const schemas = reference();
+    const committed = schemas.StackToml.properties.services.additionalProperties;
+    expectTable(shape.services);
+    expectTable(shape.services.primary);
+
+    expect(committed).not.toHaveProperty("$ref");
+    expectDocumentedFields(shape.services.primary, committed);
+    expect(committed.required).toEqual(["provider", "secrets"]);
+    expect(Object.keys(committed.properties)).toEqual(["provider", "secrets", "mcp"]);
+    expect(shape.services).toEqual({
+      primary: { provider: "supabase", secrets: ["FIXTURE_URL"], mcp: "fixture-mcp" },
+    });
+    expect(local.stack).toEqual({ project_id: config.stack.project_id });
+    expect(local.services).toEqual({
+      primary: {
+        resource_id: "fixture-resource",
+        region: "fixture-region",
+        meta: metadata,
+        created_at: "fixture-time",
+        created_by: "fixture-owner",
+      },
+    });
+    expect(merged.services.primary).toEqual(config.services.primary);
+    expectDocumentedFields(merged.services.primary, schemas.ServiceEntry);
+    expect(schemas.ServiceEntry.required).toEqual(["provider", "secrets", "created_at"]);
+    expect(schemas.ServiceEntry.properties.created_at).not.toHaveProperty("format");
+    expect(schemas.ServiceEntry.properties.meta.type).toBe("object");
+    expect(schemas.ServiceEntry.properties.secrets.items.type).toBe("string");
+    expectDocumentedFields(merged.stack, {
+      properties: { version: {}, project_id: {}, template: {} },
+    });
+  });
+
+  test("merged entry documentation covers actual instances independently of the committed subset", async () => {
+    const config = emptyConfig();
+    config.services.custom_slot = {
+      provider: "neon",
+      secrets: [],
+      resource_id: "opaque-fixture-id",
+      meta: { arbitrary: "not a credential fixture" },
+      created_at: "not-a-date-validator",
+    };
+    await writeConfig(config, cwd);
+    const merged = await readConfig(cwd);
+    const schema = reference().ServiceEntry;
+
+    expectDocumentedFields(merged.services.custom_slot, schema);
+    expect(schema.properties.resource_id.type).toBe("string");
+    expect(schema.properties.meta.type).toBe("object");
+    expect(schema.properties.created_at.type).toBe("string");
+    expect(merged.services.custom_slot.secrets).toEqual([]);
+    expect(merged.services.custom_slot.mcp).toBeUndefined();
+  });
+
+  test("the writer preserves other version strings and an empty environments array", async () => {
+    const config = emptyConfig();
+    config.stack.version = "fixture-future-version";
+    config.environments = [];
+    config.services.first = { provider: "neon", secrets: [], created_at: "fixture" };
+    config.services.second = { provider: "neon", secrets: [], created_at: "fixture" };
+    await writeConfig(config, cwd);
+    const shape = parseToml(readFileSync(join(cwd, CONFIG_FILENAME), "utf-8"));
+    const schema = reference().StackToml;
+
+    expect(shape.stack).toEqual({ version: "fixture-future-version" });
+    expect(shape.environments).toEqual([]);
+    expect(shape.services).toEqual({
+      first: { provider: "neon", secrets: [] },
+      second: { provider: "neon", secrets: [] },
+    });
+    expect(schema.properties.stack.properties.version.type).toBe(typeof config.stack.version);
+    expect(schema.properties.stack.properties.version).not.toHaveProperty("const");
+    expect(schema.properties.stack.properties.version).not.toHaveProperty("enum");
+    expect(schema.properties.environments.type).toBe("array");
+    expect(schema.properties.environments).not.toHaveProperty("minItems");
+    expect((await readConfig(cwd)).environments).toEqual([{ name: "dev", default: true }]);
+  });
+
+  test("environment documentation covers actual overrides without enforcing one default", async () => {
+    const config = emptyConfig();
+    config.environments = [
+      { name: "one", default: true, overrides: { FIXTURE_URL: "_ONE" } },
+      { name: "two", default: true },
+    ];
+    await writeConfig(config, cwd);
+    const merged = await readConfig(cwd);
+    const schema = reference().StackToml.properties.environments.items;
+
+    expect(merged.environments).toEqual(config.environments);
+    for (const entry of merged.environments) expectDocumentedFields(entry, schema);
+    expect(schema.required).toEqual(["name"]);
+    expect(schema.properties.name.type).toBe("string");
+    expect(schema.properties.default.type).toBe("boolean");
+    expect(schema.properties.overrides.additionalProperties.type).toBe("string");
+  });
+
+  test("normal defaults and legacy precedence remain distinct from canonical file documentation", async () => {
+    writeFileSync(
+      join(cwd, CONFIG_FILENAME),
+      '[stack]\nversion = "fixture"\n[services.item]\nprovider = "neon"\nsecrets = []\nregion = "ignored-shape-region"\n',
+    );
+    writeFileSync(
+      join(cwd, LOCAL_FILENAME),
+      '[stack]\nproject_id = "fixture-local"\n[services.item]\nregion = "local-region"\n',
+    );
+    const normal = await readConfig(cwd);
+    expect(normal.stack.project_id).toBe("fixture-local");
+    expect(normal.services.item.region).toBe("local-region");
+    expect(normal.services.item.created_at).toBe("1970-01-01T00:00:00Z");
+    expect(normal.environments).toEqual([{ name: "dev", default: true }]);
+
+    writeFileSync(
+      join(cwd, CONFIG_FILENAME),
+      'environments = []\n[stack]\nversion = "fixture"\nproject_id = "fixture-legacy"\n[services.item]\nresource_id = "legacy-resource"\n',
+    );
+    const legacy = await readConfig(cwd);
+    expect(legacy.stack.project_id).toBe("fixture-legacy");
+    expect(legacy.services.item.provider).toBe("item");
+    expect(legacy.services.item.secrets).toEqual([]);
+    expect(legacy.services.item.resource_id).toBe("legacy-resource");
+    expect(legacy.services.item.region).toBeUndefined();
+    expect(legacy.environments).toEqual([]);
+    expect(legacy.services.item.created_at).not.toBe("1970-01-01T00:00:00Z");
+    expect(readFileSync(join(cwd, LOCAL_FILENAME), "utf-8")).toContain("fixture-local");
+  });
+});

package/src/__tests__/config.test.ts

@@ -1,9 +1,10 @@
 import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import { mkdtempSync } from "node:fs";
+import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import {
   CONFIG_FILENAME,
+  LOCAL_FILENAME,
   emptyConfig,
   hasConfig,
   readConfig,
@@ -11,8 +12,15 @@ import {
   writeConfig,
 } from "../config.ts";
 
+const scratch: string[] = [];
+afterEach(() => {
+  for (const dir of scratch.splice(0)) rmSync(dir, { recursive: true, force: true });
+});
+
 function freshCwd(): string {
-  return mkdtempSync(join(tmpdir(), "stack-test-"));
+  const dir = mkdtempSync(join(tmpdir(), "stack-test-"));
+  scratch.push(dir);
+  return dir;
 }
 
 describe("config", () => {
@@ -20,11 +28,12 @@ describe("config", () => {
 
   beforeEach(() => {
     previousRegistryDir = process.env.STACK_REGISTRY_DIR;
-    process.env.STACK_REGISTRY_DIR = mkdtempSync(join(tmpdir(), "stack-cfg-reg-"));
+    process.env.STACK_REGISTRY_DIR = freshCwd();
   });
 
   afterEach(() => {
-    if (previousRegistryDir === undefined) delete process.env.STACK_REGISTRY_DIR;
+    if (previousRegistryDir === undefined)
+      Reflect.deleteProperty(process.env, "STACK_REGISTRY_DIR");
     else process.env.STACK_REGISTRY_DIR = previousRegistryDir;
   });
 
@@ -63,4 +72,85 @@ describe("config", () => {
     const cwd = freshCwd();
     await expect(readConfig(cwd)).rejects.toThrow(/No .stack.toml at/);
   });
+  test.each([".stack.toml", ".stack.local.toml"])(
+    "rejects malformed %s without rewriting files",
+    async (file) => {
+      const cwd = freshCwd();
+      writeFileSync(join(cwd, CONFIG_FILENAME), '[stack]\nversion = "1"');
+      writeFileSync(join(cwd, file), "[broken");
+      await expect(readConfig(cwd)).rejects.toThrow();
+      expect(readFileSync(join(cwd, file), "utf-8")).toBe("[broken");
+    },
+  );
+
+  test.each(["", "node_modules/", "node_modules/\n", " .stack.local.toml \r\n"])(
+    "gitignore update preserves existing content %j and is idempotent",
+    async (initial) => {
+      const cwd = freshCwd();
+      writeFileSync(join(cwd, ".gitignore"), initial);
+      const config = emptyConfig();
+      await writeConfig(config, cwd);
+      const first = readFileSync(join(cwd, ".gitignore"), "utf-8");
+      expect(first.startsWith(initial)).toBe(true);
+      expect(
+        first.split(/\r?\n/).filter((line) => line.trim() === ".stack.local.toml"),
+      ).toHaveLength(1);
+      await writeConfig(config, cwd);
+      expect(readFileSync(join(cwd, ".gitignore"), "utf-8")).toBe(first);
+    },
+  );
+
+  test("empty shape supplies defaults without creating local files", async () => {
+    const cwd = freshCwd();
+    writeFileSync(join(cwd, CONFIG_FILENAME), "");
+    const config = await readConfig(cwd);
+    expect(config.stack.version).toBe("1");
+    expect(config.stack.project_id).toMatch(/^stk_[a-f0-9]{12}$/);
+    expect(config.services).toEqual({});
+    expect(readFileSync(join(cwd, CONFIG_FILENAME), "utf-8")).toBe("");
+    expect(existsSync(join(cwd, LOCAL_FILENAME))).toBe(false);
+    expect(existsSync(join(cwd, ".gitignore"))).toBe(false);
+    expect(config.environments).toEqual([{ name: "dev", default: true }]);
+  });
+
+  test("empty shape keeps the local project id but does not add local-only services", async () => {
+    const cwd = freshCwd();
+    const local =
+      '[stack]\nproject_id = "stk_fixture"\n[services.orphan]\nresource_id = "fixture-resource"\n';
+    writeFileSync(join(cwd, CONFIG_FILENAME), "");
+    writeFileSync(join(cwd, LOCAL_FILENAME), local);
+
+    expect(await readConfig(cwd)).toEqual({
+      stack: { version: "1", project_id: "stk_fixture" },
+      services: {},
+      environments: [{ name: "dev", default: true }],
+    });
+    expect(readFileSync(join(cwd, CONFIG_FILENAME), "utf-8")).toBe("");
+    expect(readFileSync(join(cwd, LOCAL_FILENAME), "utf-8")).toBe(local);
+    expect(existsSync(join(cwd, ".gitignore"))).toBe(false);
+  });
+  test.each(['created_at = "2026-01-01T00:00:00Z"', 'resource_id = "resource-1"'])(
+    "legacy service marker %s normalizes optional fields",
+    async (marker) => {
+      const cwd = freshCwd();
+      writeFileSync(
+        join(cwd, CONFIG_FILENAME),
+        `[services.example]\n${marker}\nmcp = "example"\nregion = "local"\ncreated_by = "test"\n[services.example.meta]\ncount = 2\n`,
+      );
+      const config = await readConfig(cwd);
+      expect(config.stack.version).toBe("1");
+      expect(config.stack.project_id).toMatch(/^stk_[a-f0-9]{12}$/);
+      expect(config.services.example).toMatchObject({
+        provider: "example",
+        secrets: [],
+        mcp: "example",
+        region: "local",
+        created_by: "test",
+        meta: { count: 2 },
+      });
+      expect(Number.isNaN(Date.parse(config.services.example!.created_at))).toBe(false);
+      await writeConfig(config, cwd);
+      expect(await readConfig(cwd)).toEqual(config);
+    },
+  );
 });