monkeyshape 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 clinsky
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,79 @@
-# Temporary Holding Version
+# monkeyshape
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Opinionated checks, configs and conventions for humans and coding agents building software
+together on **Bun**, **TypeScript**, **Effect** and **beads**.
+
+Agents write a lot of prose and forget most of it. A rule written in `AGENTS.md` works only if
+it is loaded and noticed; a check works every time and costs no context until it fires.
+monkeyshape turns lessons into checks, keeps everything loaded automatically on a budget,
+and treats real-world results as the judge of done.
+
+```console
+$ mshape check
+src/core/cache.ts:1  rules/no-nondeterminism
+  reads the wall clock. Use Clock or DateTime.now so tests control time.
+
+src/core/client.ts  arch/host-access
+  imports 'node:fs/promises', but module 'core' has no hostAccess. Reach the host through a service in an adapter module.
+
+mshape check failed: 2 problems
+```
+
+## Install
+
+```sh
+bun add -d monkeyshape effect @biomejs/biome typescript @types/bun
+```
+
+monkeyshape runs on Bun and asks your `tsc` and `biome` which files they cover; `effect` is a
+peer dependency. Add these files (the tests build a repo from exactly these blocks):
+
+```jsonc
+// tsconfig.json
+{ "extends": "monkeyshape/tsconfig.base.json", "include": ["src", "test", "shape.config.ts"] }
+```
+
+```jsonc
+// biome.json
+{
+  "root": true,
+  "extends": ["monkeyshape/biome"],
+  "files": { "includes": ["src/**", "test/**", "shape.config.ts", "*.json"] }
+}
+```
+
+```ts
+// shape.config.ts
+import { defineConfig } from "monkeyshape";
+
+export default defineConfig({
+  arch: {
+    modules: {
+      core: { description: "Deterministic logic. No host I/O." },
+      adapters: { description: "Host I/O behind services.", mayImport: ["core"], hostAccess: true },
+    },
+  },
+});
+```
+
+```md
+<!-- AGENTS.md -->
+# My project: commands, gotchas and decision authority for agents, in 150 lines or fewer.
+```
+
+Then make it your gate: `tsc && biome ci --error-on-warnings && mshape check && bun test`.
+
+## What `mshape check` enforces
+
+| Check | Removes |
+|---|---|
+| `arch` | Layering drift, host access from pure code (common paths, statically; not a sandbox), unvetted packages, import cycles |
+| `rules` | Silent decoding, hidden clocks/env/timers, thrown errors, nested runtimes, spread errors |
+| `refs` | Docs and comments that point at paths, scripts or decisions that don't exist |
+| `budgets` | Bloated `AGENTS.md`, decision logs and memories; oversized files |
+| `coverage` | Code that escaped the typechecker or the linter and rots silently |
+
+Existing violations can be grandfathered with `mshape baseline --init`; counts may then only
+go down. Every escape hatch (`// shape-ignore <rule>: <reason>`, config allowances) needs a reason.
+
+Early (0.x). What ships and what's next: [docs/roadmap.md](docs/roadmap.md). MIT licensed.

package/config/biome.base.json

@@ -0,0 +1,71 @@
+{
+  "$schema": "https://biomejs.dev/schemas/2.5.15/schema.json",
+  "root": false,
+  "vcs": {
+    "enabled": true,
+    "clientKind": "git",
+    "useIgnoreFile": true
+  },
+  "formatter": {
+    "enabled": true,
+    "indentStyle": "space",
+    "indentWidth": 2,
+    "lineWidth": 100
+  },
+  "javascript": {
+    "formatter": {
+      "quoteStyle": "double",
+      "semicolons": "always"
+    }
+  },
+  "linter": {
+    "enabled": true,
+    "rules": {
+      "preset": "recommended",
+      "correctness": {
+        "useImportExtensions": "error"
+      },
+      "suspicious": {
+        "noExplicitAny": "error",
+        "noConsole": "error"
+      },
+      "style": {
+        "noNonNullAssertion": "error",
+        "noEnum": "error",
+        "noNamespace": "error",
+        "noParameterAssign": "error",
+        "useImportType": "error",
+        "useExportType": "error"
+      },
+      "performance": {
+        "noBarrelFile": "error",
+        "noReExportAll": "error"
+      },
+      "nursery": {
+        "noFloatingPromises": "error",
+        "noMisusedPromises": "error"
+      },
+      "complexity": {
+        "useLiteralKeys": "off"
+      }
+    }
+  },
+  "assist": {
+    "enabled": true,
+    "actions": {
+      "source": {
+        "organizeImports": "on"
+      }
+    }
+  },
+  "overrides": [
+    {
+      "includes": ["src/api/**"],
+      "linter": { "rules": { "performance": { "noBarrelFile": "off" } } }
+    },
+    {
+      "includes": ["src/cli/**", "tools/**", "**/*.test.ts", "**/*.test.tsx"],
+      "linter": { "rules": { "suspicious": { "noConsole": "off" } } }
+    }
+  ]
+}

package/config/tsconfig.base.json

@@ -0,0 +1,31 @@
+{
+  "$schema": "https://json.schemastore.org/tsconfig",
+  "compilerOptions": {
+    "target": "ESNext",
+    "lib": ["ESNext"],
+    "module": "Preserve",
+    "moduleResolution": "bundler",
+    "moduleDetection": "force",
+    "types": ["bun"],
+    "noEmit": true,
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "erasableSyntaxOnly": true,
+    "isolatedModules": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+
+    "strict": true,
+    "noUncheckedIndexedAccess": true,
+    "exactOptionalPropertyTypes": true,
+    "noImplicitOverride": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true,
+    "noPropertyAccessFromIndexSignature": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noUncheckedSideEffectImports": true,
+    "allowUnreachableCode": false,
+    "allowUnusedLabels": false
+  }
+}

package/package.json

@@ -1,6 +1,66 @@
 {
   "name": "monkeyshape",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "Opinionated checks, configs and conventions for humans and coding agents building together on Bun, TypeScript, Effect and beads.",
+  "keywords": [
+    "bun",
+    "typescript",
+    "effect",
+    "effect-ts",
+    "static-analysis",
+    "linter",
+    "quality-gate",
+    "coding-agents",
+    "ai-agents",
+    "developer-tools",
+    "beads"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/clinsky/monkeyshape.git"
+  },
+  "homepage": "https://github.com/clinsky/monkeyshape#readme",
+  "bugs": {
+    "url": "https://github.com/clinsky/monkeyshape/issues"
+  },
+  "type": "module",
+  "packageManager": "bun@1.4.2",
+  "engines": {
+    "bun": ">=1.4.2"
+  },
+  "bin": {
+    "mshape": "./src/cli/main.ts"
+  },
+  "exports": {
+    ".": "./src/api/monkeyshape.ts",
+    "./tsconfig.base.json": "./config/tsconfig.base.json",
+    "./biome": "./config/biome.base.json"
+  },
+  "files": [
+    "src",
+    "config",
+    "!src/**/*.test.ts",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "typecheck": "tsc -p .",
+    "lint": "biome ci --error-on-warnings .",
+    "fix": "biome check --write .",
+    "shape": "bun src/cli/main.ts check",
+    "check": "bun run typecheck && bun run lint && bun run shape && bun test"
+  },
+  "dependencies": {
+    "oxc-parser": "0.156.0"
+  },
+  "peerDependencies": {
+    "effect": "4.0.0"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "2.5.15",
+    "@types/bun": "1.4.2",
+    "effect": "4.0.0",
+    "typescript": "7.0.2"
+  }
+}

package/src/adapters/baseline.ts

@@ -0,0 +1,55 @@
+/** `.shape/baseline.json`: grandfathered violation counts per rule and file. */
+import { Effect, Schema } from "effect";
+import type { Counts } from "../core/ratchet.ts";
+import { decodeStrict } from "../helpers/decodeStrict.ts";
+import { WorkspaceError } from "../schemas/errors.ts";
+import { readText } from "./workspace.ts";
+
+export const BASELINE_FILE = ".shape/baseline.json";
+
+const Baseline = Schema.Struct({
+  version: Schema.Literal(1),
+  counts: Schema.Record(Schema.String, Schema.Record(Schema.String, Schema.Int)),
+});
+
+export const readBaseline = (root: string) =>
+  Effect.gen(function* () {
+    if (!(yield* Effect.promise(() => Bun.file(`${root}/${BASELINE_FILE}`).exists())))
+      return {} as Counts;
+    const text = yield* readText(root, BASELINE_FILE);
+    const json = yield* Effect.try({
+      try: (): unknown => JSON.parse(text),
+      catch: () =>
+        new WorkspaceError({ operation: "parse", path: BASELINE_FILE, reason: "not valid JSON" }),
+    });
+    const baseline = yield* decodeStrict(Baseline)(json).pipe(
+      Effect.mapError(
+        (error) =>
+          new WorkspaceError({ operation: "decode", path: BASELINE_FILE, reason: error.message }),
+      ),
+    );
+    return baseline.counts;
+  });
+
+const sorted = (counts: Counts): Counts =>
+  Object.fromEntries(
+    Object.keys(counts)
+      .sort()
+      .map((rule) => [
+        rule,
+        Object.fromEntries(
+          Object.entries(counts[rule] ?? {}).sort(([a], [b]) => a.localeCompare(b)),
+        ),
+      ]),
+  );
+
+export const writeBaseline = (root: string, counts: Counts) =>
+  Effect.tryPromise({
+    try: () =>
+      Bun.write(
+        `${root}/${BASELINE_FILE}`,
+        `${JSON.stringify({ version: 1, counts: sorted(counts) }, null, 2)}\n`,
+      ),
+    catch: (cause) =>
+      new WorkspaceError({ operation: "write", path: BASELINE_FILE, reason: String(cause) }),
+  });

package/src/adapters/config.ts

@@ -0,0 +1,25 @@
+/** Loads `shape.config.ts` by importing it, then decodes it strictly. */
+import { Effect } from "effect";
+import { decodeStrict } from "../helpers/decodeStrict.ts";
+import { resolveConfig, ShapeConfig } from "../schemas/config.ts";
+import { ConfigError } from "../schemas/errors.ts";
+
+export const CONFIG_FILE = "shape.config.ts";
+
+/** `path` overrides the repo's own config, e.g. to try monkeyshape on a repo before adopting it. */
+export const loadConfig = (root: string, path = `${root}/${CONFIG_FILE}`) =>
+  Effect.gen(function* () {
+    if (!(yield* Effect.promise(() => Bun.file(path).exists())))
+      return yield* Effect.fail(
+        new ConfigError({ path: CONFIG_FILE, reason: "not found; every adopting repo has one" }),
+      );
+    const module = yield* Effect.tryPromise({
+      try: () => import(path) as Promise<{ readonly default?: unknown }>,
+      catch: (cause) =>
+        new ConfigError({ path: CONFIG_FILE, reason: `could not load: ${String(cause)}` }),
+    });
+    const config = yield* decodeStrict(ShapeConfig)(module.default).pipe(
+      Effect.mapError((error) => new ConfigError({ path: CONFIG_FILE, reason: error.message })),
+    );
+    return resolveConfig(config);
+  });

package/src/adapters/workspace.ts

@@ -0,0 +1,268 @@
+/** Loads the repo into a `Snapshot`: git's file list, the texts checks read, and what bd, tsc and biome report. */
+import { realpath, stat } from "node:fs/promises";
+import { posix } from "node:path";
+import { Effect } from "effect";
+import { parseJsonc } from "../core/coverage.ts";
+import { type Integration, isTsSource, type Snapshot } from "../core/model.ts";
+import type { ResolvedConfig } from "../schemas/config.ts";
+import { WorkspaceError } from "../schemas/errors.ts";
+
+const run = (root: string, command: ReadonlyArray<string>) =>
+  Effect.tryPromise({
+    try: async () => {
+      const child = Bun.spawn([...command], { cwd: root, stdout: "pipe", stderr: "ignore" });
+      const stdout = await new Response(child.stdout).text();
+      return { stdout, code: await child.exited };
+    },
+    catch: (cause) =>
+      new WorkspaceError({ operation: "run", path: command.join(" "), reason: String(cause) }),
+  });
+
+/** For optional tools: a spawn failure is an exit code to report, not a reason to abort. */
+const runTool = (root: string, command: ReadonlyArray<string>) =>
+  run(root, command).pipe(Effect.orElseSucceed(() => ({ stdout: "", code: -1 })));
+
+export const readText = (root: string, path: string) =>
+  Effect.tryPromise({
+    try: () => Bun.file(`${root}/${path}`).text(),
+    catch: (cause) => new WorkspaceError({ operation: "read", path, reason: String(cause) }),
+  });
+
+/** Files and directories alike: git lists a submodule as one entry, and it is a directory. */
+const exists = (root: string, path: string) =>
+  Effect.promise(() =>
+    stat(`${root}/${path}`).then(
+      () => true,
+      () => false,
+    ),
+  );
+
+const listFiles = (root: string) =>
+  Effect.gen(function* () {
+    const result = yield* run(root, [
+      "git",
+      "ls-files",
+      "--cached",
+      "--others",
+      "--exclude-standard",
+      "-z",
+    ]);
+    if (result.code !== 0)
+      return yield* Effect.fail(
+        new WorkspaceError({ operation: "list", path: root, reason: "not a git repository" }),
+      );
+    // Nested repositories and worktrees show up as a directory entry; they are not ours.
+    return result.stdout.split("\0").filter((file) => file !== "" && !file.endsWith("/"));
+  });
+
+type Loaded<A> = { readonly integration: Integration; readonly value: A | undefined };
+
+const failed = <A>(reason: string): Loaded<A> => ({
+  integration: { state: "failed", reason },
+  value: undefined,
+});
+
+const jsonRows = (stdout: string): ReadonlyArray<unknown> | undefined => {
+  const parsed = parseJsonc(stdout);
+  // `bd list --limit 0 --json` wraps the rows as `{ issues: [...] }`; limited lists are bare.
+  const rows =
+    typeof parsed === "object" && parsed !== null && "issues" in parsed ? parsed.issues : parsed;
+  return Array.isArray(rows) ? rows : undefined;
+};
+
+/** bd memories and every bead id. A repo without `.beads` is absent; bd missing is unavailable. */
+const beads = (root: string) =>
+  Effect.gen(function* () {
+    type Value = { memories: ReadonlyMap<string, string>; ids: ReadonlySet<string> };
+    if (!(yield* exists(root, ".beads/config.yaml")))
+      return { integration: { state: "absent" }, value: undefined } satisfies Loaded<Value>;
+    if (Bun.which("bd") === null)
+      return {
+        integration: { state: "unavailable", reason: "bd is not on PATH" },
+        value: undefined,
+      } satisfies Loaded<Value>;
+    const memories = yield* runTool(root, ["bd", "memories", "--json"]);
+    const parsedMemories = memories.code === 0 ? parseJsonc(memories.stdout) : undefined;
+    if (typeof parsedMemories !== "object" || parsedMemories === null)
+      return failed<Value>(`\`bd memories --json\` exited ${memories.code} or printed no object`);
+    const list = yield* runTool(root, [
+      "bd",
+      "list",
+      "--all",
+      "--brief",
+      "--skip-labels",
+      "--limit",
+      "0",
+      "--json",
+    ]);
+    const rows = list.code === 0 ? jsonRows(list.stdout) : undefined;
+    if (rows === undefined)
+      return failed<Value>(`\`bd list --json\` exited ${list.code} or printed no rows`);
+    const value: Value = {
+      memories: new Map(
+        Object.entries(parsedMemories).filter(
+          (entry): entry is [string, string] => typeof entry[1] === "string",
+        ),
+      ),
+      ids: new Set(
+        rows.flatMap((issue) =>
+          typeof issue === "object" &&
+          issue !== null &&
+          "id" in issue &&
+          typeof issue.id === "string"
+            ? [issue.id]
+            : [],
+        ),
+      ),
+    };
+    return { integration: { state: "ok" }, value } satisfies Loaded<Value>;
+  });
+
+/**
+ * A tool installed in the repo, as a command. Run through the current bun: the bin shims
+ * start with `#!/usr/bin/env node`, and a Bun-only machine has no node.
+ */
+const localBin = (root: string, name: string) =>
+  Effect.map(exists(root, `node_modules/.bin/${name}`), (found) =>
+    found ? [process.execPath, `${root}/node_modules/.bin/${name}`] : undefined,
+  );
+
+/**
+ * The tsconfigs a project's references point at. A reference names a tsconfig file or a
+ * directory holding `tsconfig.json`; references are not inherited through `extends`, so the
+ * file's own JSON is the whole answer. Unreadable files yield none; tsc reports them itself.
+ */
+const referencesOf = (root: string, tsconfig: string) =>
+  Effect.gen(function* () {
+    const text = yield* readText(root, tsconfig).pipe(Effect.orElseSucceed(() => "{}"));
+    const parsed = parseJsonc(text);
+    const references =
+      typeof parsed === "object" && parsed !== null && "references" in parsed
+        ? parsed.references
+        : undefined;
+    if (!Array.isArray(references)) return [];
+    const out: Array<string> = [];
+    for (const reference of references) {
+      if (typeof reference !== "object" || reference === null || !("path" in reference)) continue;
+      if (typeof reference.path !== "string") continue;
+      const target = posix.normalize(posix.join(posix.dirname(tsconfig), reference.path));
+      const isDirectory = yield* Effect.promise(() =>
+        stat(`${root}/${target}`).then(
+          (info) => info.isDirectory(),
+          () => false,
+        ),
+      );
+      out.push(isDirectory ? posix.join(target, "tsconfig.json") : target);
+    }
+    return out;
+  });
+
+/**
+ * The union of every configured tsconfig's program and, transitively, of every project it
+ * references, as tsc itself resolves each one. `tsc -p` checks one project and `--build`
+ * won't list files, so the reference graph is walked here, each project once.
+ */
+const typechecked = (root: string, realRoot: string, tsconfigs: ReadonlyArray<string>) =>
+  Effect.gen(function* () {
+    const tsc = yield* localBin(root, "tsc");
+    if (tsc === undefined)
+      return {
+        integration: { state: "unavailable", reason: "typescript is not installed" },
+        value: undefined,
+      } satisfies Loaded<ReadonlySet<string>>;
+    const files = new Set<string>();
+    const seen = new Set<string>();
+    const queue = tsconfigs.map((tsconfig) => posix.normalize(tsconfig));
+    for (let tsconfig = queue.shift(); tsconfig !== undefined; tsconfig = queue.shift()) {
+      if (seen.has(tsconfig)) continue;
+      seen.add(tsconfig);
+      const result = yield* runTool(root, [...tsc, "-p", tsconfig, "--listFilesOnly"]);
+      if (result.code !== 0)
+        return failed<ReadonlySet<string>>(
+          `\`tsc -p ${tsconfig} --listFilesOnly\` exited ${result.code}`,
+        );
+      for (const line of result.stdout.split("\n"))
+        if (line.startsWith(`${realRoot}/`)) files.add(line.slice(realRoot.length + 1));
+      queue.push(...(yield* referencesOf(root, tsconfig)));
+    }
+    return { integration: { state: "ok" }, value: files } satisfies Loaded<ReadonlySet<string>>;
+  });
+
+/** The files biome processes, from its verbose report, with `extends` and ignores resolved. */
+const linted = (root: string) =>
+  Effect.gen(function* () {
+    const biome = yield* localBin(root, "biome");
+    if (biome === undefined)
+      return {
+        integration: { state: "unavailable", reason: "@biomejs/biome is not installed" },
+        value: undefined,
+      } satisfies Loaded<ReadonlySet<string>>;
+    const result = yield* runTool(root, [
+      ...biome,
+      "lint",
+      "--verbose",
+      "--colors=off",
+      "--max-diagnostics=0",
+      ".",
+    ]);
+    const report = result.stdout.split("Files processed:")[1];
+    if (report === undefined)
+      return failed<ReadonlySet<string>>(
+        `\`biome lint --verbose\` printed no "Files processed:" list (exit ${result.code})`,
+      );
+    const files = new Set(
+      report.split("\n").flatMap((line) => {
+        const match = /^\s+- (.+)$/.exec(line);
+        return match?.[1] === undefined ? [] : [match[1].trim()];
+      }),
+    );
+    return { integration: { state: "ok" }, value: files } satisfies Loaded<ReadonlySet<string>>;
+  });
+
+export const loadSnapshot = (root: string, config: ResolvedConfig) =>
+  Effect.gen(function* () {
+    const listed = yield* listFiles(root);
+    // A file deleted but not yet staged is still listed; it isn't part of the repo now.
+    const found = yield* Effect.forEach(listed, (file) => exists(root, file), { concurrency: 32 });
+    const present = listed.filter((_, i) => found[i] === true);
+    const configs = new Set([...config.coverage.tsconfigs, config.coverage.biome, "package.json"]);
+    const wanted = present.filter(
+      (file) => isTsSource(file) || file.endsWith(".md") || configs.has(file),
+    );
+    const texts = new Map(
+      yield* Effect.forEach(
+        wanted,
+        (file) => Effect.map(readText(root, file), (text) => [file, text] as const),
+        {
+          concurrency: 32,
+        },
+      ),
+    );
+    const manifest = parseJsonc(texts.get("package.json") ?? "{}");
+    const scripts =
+      typeof manifest === "object" &&
+      manifest !== null &&
+      "scripts" in manifest &&
+      typeof manifest.scripts === "object"
+        ? Object.keys(manifest.scripts ?? {})
+        : [];
+    const realRoot = yield* Effect.promise(() => realpath(root));
+    const loadedBeads = yield* beads(root);
+    const loadedTsc = yield* typechecked(root, realRoot, config.coverage.tsconfigs);
+    const loadedBiome = yield* linted(root);
+    const snapshot: Snapshot = {
+      files: present,
+      texts,
+      packageScripts: new Set(scripts),
+      memories: loadedBeads.value?.memories,
+      beadIds: loadedBeads.value?.ids,
+      typechecked: loadedTsc.value,
+      linted: loadedBiome.value,
+      integrations: {
+        beads: loadedBeads.integration,
+        tsc: loadedTsc.integration,
+        biome: loadedBiome.integration,
+      },
+    };
+    return snapshot;
+  });

package/src/api/monkeyshape.ts

@@ -0,0 +1,8 @@
+/** The public surface: what an adopter imports from `monkeyshape`. */
+import type { ShapeConfig } from "../schemas/config.ts";
+
+export { decodeStrict } from "../helpers/decodeStrict.ts";
+export type { Allowance, ModuleRule, ShapeConfig } from "../schemas/config.ts";
+
+/** Identity, for type-checking `shape.config.ts`: `export default defineConfig({ ... })`. */
+export const defineConfig = (config: ShapeConfig): ShapeConfig => config;