apexrest 0.4.0-beta.1

package/dist/runtime/chunk-3GSS6SJH.mjs

@@ -0,0 +1,1424 @@
+import { createRequire as __createRequire } from 'node:module'; const require = __createRequire(import.meta.url);
+import {
+  VERSION
+} from "./chunk-Z6Y72JVG.mjs";
+import {
+  Client,
+  StdioClientTransport,
+  ToolchainService,
+  managedHome,
+  requireTrust,
+  require_applicator,
+  require_codegen,
+  require_compile,
+  require_core,
+  require_core2,
+  require_dependencies,
+  require_discriminator,
+  require_format,
+  require_metadata,
+  require_names,
+  require_ref,
+  require_ref_error,
+  require_util,
+  require_validate,
+  require_validation,
+  require_validation_error,
+  resourceRoot,
+  runProcess,
+  runtimeState
+} from "./chunk-2SZCZZ3J.mjs";
+import {
+  Fault,
+  __commonJS,
+  __toESM,
+  atomicWrite,
+  canonical,
+  contained,
+  exists,
+  hash,
+  inventory,
+  readJson,
+  withLock,
+  writeJson
+} from "./chunk-IPU64TJI.mjs";
+
+// node_modules/ajv/dist/vocabularies/dynamic/dynamicAnchor.js
+var require_dynamicAnchor = __commonJS({
+  "node_modules/ajv/dist/vocabularies/dynamic/dynamicAnchor.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.dynamicAnchor = void 0;
+    var codegen_1 = require_codegen();
+    var names_1 = require_names();
+    var compile_1 = require_compile();
+    var ref_1 = require_ref();
+    var def = {
+      keyword: "$dynamicAnchor",
+      schemaType: "string",
+      code: (cxt) => dynamicAnchor(cxt, cxt.schema)
+    };
+    function dynamicAnchor(cxt, anchor) {
+      const { gen, it } = cxt;
+      it.schemaEnv.root.dynamicAnchors[anchor] = true;
+      const v = (0, codegen_1._)`${names_1.default.dynamicAnchors}${(0, codegen_1.getProperty)(anchor)}`;
+      const validate = it.errSchemaPath === "#" ? it.validateName : _getValidate(cxt);
+      gen.if((0, codegen_1._)`!${v}`, () => gen.assign(v, validate));
+    }
+    exports.dynamicAnchor = dynamicAnchor;
+    function _getValidate(cxt) {
+      const { schemaEnv, schema, self } = cxt.it;
+      const { root, baseId, localRefs, meta } = schemaEnv.root;
+      const { schemaId } = self.opts;
+      const sch = new compile_1.SchemaEnv({ schema, schemaId, root, baseId, localRefs, meta });
+      compile_1.compileSchema.call(self, sch);
+      return (0, ref_1.getValidate)(cxt, sch);
+    }
+    exports.default = def;
+  }
+});
+
+// node_modules/ajv/dist/vocabularies/dynamic/dynamicRef.js
+var require_dynamicRef = __commonJS({
+  "node_modules/ajv/dist/vocabularies/dynamic/dynamicRef.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.dynamicRef = void 0;
+    var codegen_1 = require_codegen();
+    var names_1 = require_names();
+    var ref_1 = require_ref();
+    var def = {
+      keyword: "$dynamicRef",
+      schemaType: "string",
+      code: (cxt) => dynamicRef(cxt, cxt.schema)
+    };
+    function dynamicRef(cxt, ref) {
+      const { gen, keyword, it } = cxt;
+      if (ref[0] !== "#")
+        throw new Error(`"${keyword}" only supports hash fragment reference`);
+      const anchor = ref.slice(1);
+      if (it.allErrors) {
+        _dynamicRef();
+      } else {
+        const valid = gen.let("valid", false);
+        _dynamicRef(valid);
+        cxt.ok(valid);
+      }
+      function _dynamicRef(valid) {
+        if (it.schemaEnv.root.dynamicAnchors[anchor]) {
+          const v = gen.let("_v", (0, codegen_1._)`${names_1.default.dynamicAnchors}${(0, codegen_1.getProperty)(anchor)}`);
+          gen.if(v, _callRef(v, valid), _callRef(it.validateName, valid));
+        } else {
+          _callRef(it.validateName, valid)();
+        }
+      }
+      function _callRef(validate, valid) {
+        return valid ? () => gen.block(() => {
+          (0, ref_1.callRef)(cxt, validate);
+          gen.let(valid, true);
+        }) : () => (0, ref_1.callRef)(cxt, validate);
+      }
+    }
+    exports.dynamicRef = dynamicRef;
+    exports.default = def;
+  }
+});
+
+// node_modules/ajv/dist/vocabularies/dynamic/recursiveAnchor.js
+var require_recursiveAnchor = __commonJS({
+  "node_modules/ajv/dist/vocabularies/dynamic/recursiveAnchor.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var dynamicAnchor_1 = require_dynamicAnchor();
+    var util_1 = require_util();
+    var def = {
+      keyword: "$recursiveAnchor",
+      schemaType: "boolean",
+      code(cxt) {
+        if (cxt.schema)
+          (0, dynamicAnchor_1.dynamicAnchor)(cxt, "");
+        else
+          (0, util_1.checkStrictMode)(cxt.it, "$recursiveAnchor: false is ignored");
+      }
+    };
+    exports.default = def;
+  }
+});
+
+// node_modules/ajv/dist/vocabularies/dynamic/recursiveRef.js
+var require_recursiveRef = __commonJS({
+  "node_modules/ajv/dist/vocabularies/dynamic/recursiveRef.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var dynamicRef_1 = require_dynamicRef();
+    var def = {
+      keyword: "$recursiveRef",
+      schemaType: "string",
+      code: (cxt) => (0, dynamicRef_1.dynamicRef)(cxt, cxt.schema)
+    };
+    exports.default = def;
+  }
+});
+
+// node_modules/ajv/dist/vocabularies/dynamic/index.js
+var require_dynamic = __commonJS({
+  "node_modules/ajv/dist/vocabularies/dynamic/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var dynamicAnchor_1 = require_dynamicAnchor();
+    var dynamicRef_1 = require_dynamicRef();
+    var recursiveAnchor_1 = require_recursiveAnchor();
+    var recursiveRef_1 = require_recursiveRef();
+    var dynamic = [dynamicAnchor_1.default, dynamicRef_1.default, recursiveAnchor_1.default, recursiveRef_1.default];
+    exports.default = dynamic;
+  }
+});
+
+// node_modules/ajv/dist/vocabularies/validation/dependentRequired.js
+var require_dependentRequired = __commonJS({
+  "node_modules/ajv/dist/vocabularies/validation/dependentRequired.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var dependencies_1 = require_dependencies();
+    var def = {
+      keyword: "dependentRequired",
+      type: "object",
+      schemaType: "object",
+      error: dependencies_1.error,
+      code: (cxt) => (0, dependencies_1.validatePropertyDeps)(cxt)
+    };
+    exports.default = def;
+  }
+});
+
+// node_modules/ajv/dist/vocabularies/applicator/dependentSchemas.js
+var require_dependentSchemas = __commonJS({
+  "node_modules/ajv/dist/vocabularies/applicator/dependentSchemas.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var dependencies_1 = require_dependencies();
+    var def = {
+      keyword: "dependentSchemas",
+      type: "object",
+      schemaType: "object",
+      code: (cxt) => (0, dependencies_1.validateSchemaDeps)(cxt)
+    };
+    exports.default = def;
+  }
+});
+
+// node_modules/ajv/dist/vocabularies/validation/limitContains.js
+var require_limitContains = __commonJS({
+  "node_modules/ajv/dist/vocabularies/validation/limitContains.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var util_1 = require_util();
+    var def = {
+      keyword: ["maxContains", "minContains"],
+      type: "array",
+      schemaType: "number",
+      code({ keyword, parentSchema, it }) {
+        if (parentSchema.contains === void 0) {
+          (0, util_1.checkStrictMode)(it, `"${keyword}" without "contains" is ignored`);
+        }
+      }
+    };
+    exports.default = def;
+  }
+});
+
+// node_modules/ajv/dist/vocabularies/next.js
+var require_next = __commonJS({
+  "node_modules/ajv/dist/vocabularies/next.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var dependentRequired_1 = require_dependentRequired();
+    var dependentSchemas_1 = require_dependentSchemas();
+    var limitContains_1 = require_limitContains();
+    var next = [dependentRequired_1.default, dependentSchemas_1.default, limitContains_1.default];
+    exports.default = next;
+  }
+});
+
+// node_modules/ajv/dist/vocabularies/unevaluated/unevaluatedProperties.js
+var require_unevaluatedProperties = __commonJS({
+  "node_modules/ajv/dist/vocabularies/unevaluated/unevaluatedProperties.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var codegen_1 = require_codegen();
+    var util_1 = require_util();
+    var names_1 = require_names();
+    var error = {
+      message: "must NOT have unevaluated properties",
+      params: ({ params }) => (0, codegen_1._)`{unevaluatedProperty: ${params.unevaluatedProperty}}`
+    };
+    var def = {
+      keyword: "unevaluatedProperties",
+      type: "object",
+      schemaType: ["boolean", "object"],
+      trackErrors: true,
+      error,
+      code(cxt) {
+        const { gen, schema, data, errsCount, it } = cxt;
+        if (!errsCount)
+          throw new Error("ajv implementation error");
+        const { allErrors, props } = it;
+        if (props instanceof codegen_1.Name) {
+          gen.if((0, codegen_1._)`${props} !== true`, () => gen.forIn("key", data, (key) => gen.if(unevaluatedDynamic(props, key), () => unevaluatedPropCode(key))));
+        } else if (props !== true) {
+          gen.forIn("key", data, (key) => props === void 0 ? unevaluatedPropCode(key) : gen.if(unevaluatedStatic(props, key), () => unevaluatedPropCode(key)));
+        }
+        it.props = true;
+        cxt.ok((0, codegen_1._)`${errsCount} === ${names_1.default.errors}`);
+        function unevaluatedPropCode(key) {
+          if (schema === false) {
+            cxt.setParams({ unevaluatedProperty: key });
+            cxt.error();
+            if (!allErrors)
+              gen.break();
+            return;
+          }
+          if (!(0, util_1.alwaysValidSchema)(it, schema)) {
+            const valid = gen.name("valid");
+            cxt.subschema({
+              keyword: "unevaluatedProperties",
+              dataProp: key,
+              dataPropType: util_1.Type.Str
+            }, valid);
+            if (!allErrors)
+              gen.if((0, codegen_1.not)(valid), () => gen.break());
+          }
+        }
+        function unevaluatedDynamic(evaluatedProps, key) {
+          return (0, codegen_1._)`!${evaluatedProps} || !${evaluatedProps}[${key}]`;
+        }
+        function unevaluatedStatic(evaluatedProps, key) {
+          const ps = [];
+          for (const p in evaluatedProps) {
+            if (evaluatedProps[p] === true)
+              ps.push((0, codegen_1._)`${key} !== ${p}`);
+          }
+          return (0, codegen_1.and)(...ps);
+        }
+      }
+    };
+    exports.default = def;
+  }
+});
+
+// node_modules/ajv/dist/vocabularies/unevaluated/unevaluatedItems.js
+var require_unevaluatedItems = __commonJS({
+  "node_modules/ajv/dist/vocabularies/unevaluated/unevaluatedItems.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var codegen_1 = require_codegen();
+    var util_1 = require_util();
+    var error = {
+      message: ({ params: { len } }) => (0, codegen_1.str)`must NOT have more than ${len} items`,
+      params: ({ params: { len } }) => (0, codegen_1._)`{limit: ${len}}`
+    };
+    var def = {
+      keyword: "unevaluatedItems",
+      type: "array",
+      schemaType: ["boolean", "object"],
+      error,
+      code(cxt) {
+        const { gen, schema, data, it } = cxt;
+        const items = it.items || 0;
+        if (items === true)
+          return;
+        const len = gen.const("len", (0, codegen_1._)`${data}.length`);
+        if (schema === false) {
+          cxt.setParams({ len: items });
+          cxt.fail((0, codegen_1._)`${len} > ${items}`);
+        } else if (typeof schema == "object" && !(0, util_1.alwaysValidSchema)(it, schema)) {
+          const valid = gen.var("valid", (0, codegen_1._)`${len} <= ${items}`);
+          gen.if((0, codegen_1.not)(valid), () => validateItems(valid, items));
+          cxt.ok(valid);
+        }
+        it.items = true;
+        function validateItems(valid, from) {
+          gen.forRange("i", from, len, (i) => {
+            cxt.subschema({ keyword: "unevaluatedItems", dataProp: i, dataPropType: util_1.Type.Num }, valid);
+            if (!it.allErrors)
+              gen.if((0, codegen_1.not)(valid), () => gen.break());
+          });
+        }
+      }
+    };
+    exports.default = def;
+  }
+});
+
+// node_modules/ajv/dist/vocabularies/unevaluated/index.js
+var require_unevaluated = __commonJS({
+  "node_modules/ajv/dist/vocabularies/unevaluated/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var unevaluatedProperties_1 = require_unevaluatedProperties();
+    var unevaluatedItems_1 = require_unevaluatedItems();
+    var unevaluated = [unevaluatedProperties_1.default, unevaluatedItems_1.default];
+    exports.default = unevaluated;
+  }
+});
+
+// node_modules/ajv/dist/vocabularies/draft2020.js
+var require_draft2020 = __commonJS({
+  "node_modules/ajv/dist/vocabularies/draft2020.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var core_1 = require_core2();
+    var validation_1 = require_validation();
+    var applicator_1 = require_applicator();
+    var dynamic_1 = require_dynamic();
+    var next_1 = require_next();
+    var unevaluated_1 = require_unevaluated();
+    var format_1 = require_format();
+    var metadata_1 = require_metadata();
+    var draft2020Vocabularies = [
+      dynamic_1.default,
+      core_1.default,
+      validation_1.default,
+      (0, applicator_1.default)(true),
+      format_1.default,
+      metadata_1.metadataVocabulary,
+      metadata_1.contentVocabulary,
+      next_1.default,
+      unevaluated_1.default
+    ];
+    exports.default = draft2020Vocabularies;
+  }
+});
+
+// node_modules/ajv/dist/refs/json-schema-2020-12/schema.json
+var require_schema = __commonJS({
+  "node_modules/ajv/dist/refs/json-schema-2020-12/schema.json"(exports, module) {
+    module.exports = {
+      $schema: "https://json-schema.org/draft/2020-12/schema",
+      $id: "https://json-schema.org/draft/2020-12/schema",
+      $vocabulary: {
+        "https://json-schema.org/draft/2020-12/vocab/core": true,
+        "https://json-schema.org/draft/2020-12/vocab/applicator": true,
+        "https://json-schema.org/draft/2020-12/vocab/unevaluated": true,
+        "https://json-schema.org/draft/2020-12/vocab/validation": true,
+        "https://json-schema.org/draft/2020-12/vocab/meta-data": true,
+        "https://json-schema.org/draft/2020-12/vocab/format-annotation": true,
+        "https://json-schema.org/draft/2020-12/vocab/content": true
+      },
+      $dynamicAnchor: "meta",
+      title: "Core and Validation specifications meta-schema",
+      allOf: [
+        { $ref: "meta/core" },
+        { $ref: "meta/applicator" },
+        { $ref: "meta/unevaluated" },
+        { $ref: "meta/validation" },
+        { $ref: "meta/meta-data" },
+        { $ref: "meta/format-annotation" },
+        { $ref: "meta/content" }
+      ],
+      type: ["object", "boolean"],
+      $comment: "This meta-schema also defines keywords that have appeared in previous drafts in order to prevent incompatible extensions as they remain in common use.",
+      properties: {
+        definitions: {
+          $comment: '"definitions" has been replaced by "$defs".',
+          type: "object",
+          additionalProperties: { $dynamicRef: "#meta" },
+          deprecated: true,
+          default: {}
+        },
+        dependencies: {
+          $comment: '"dependencies" has been split and replaced by "dependentSchemas" and "dependentRequired" in order to serve their differing semantics.',
+          type: "object",
+          additionalProperties: {
+            anyOf: [{ $dynamicRef: "#meta" }, { $ref: "meta/validation#/$defs/stringArray" }]
+          },
+          deprecated: true,
+          default: {}
+        },
+        $recursiveAnchor: {
+          $comment: '"$recursiveAnchor" has been replaced by "$dynamicAnchor".',
+          $ref: "meta/core#/$defs/anchorString",
+          deprecated: true
+        },
+        $recursiveRef: {
+          $comment: '"$recursiveRef" has been replaced by "$dynamicRef".',
+          $ref: "meta/core#/$defs/uriReferenceString",
+          deprecated: true
+        }
+      }
+    };
+  }
+});
+
+// node_modules/ajv/dist/refs/json-schema-2020-12/meta/applicator.json
+var require_applicator2 = __commonJS({
+  "node_modules/ajv/dist/refs/json-schema-2020-12/meta/applicator.json"(exports, module) {
+    module.exports = {
+      $schema: "https://json-schema.org/draft/2020-12/schema",
+      $id: "https://json-schema.org/draft/2020-12/meta/applicator",
+      $vocabulary: {
+        "https://json-schema.org/draft/2020-12/vocab/applicator": true
+      },
+      $dynamicAnchor: "meta",
+      title: "Applicator vocabulary meta-schema",
+      type: ["object", "boolean"],
+      properties: {
+        prefixItems: { $ref: "#/$defs/schemaArray" },
+        items: { $dynamicRef: "#meta" },
+        contains: { $dynamicRef: "#meta" },
+        additionalProperties: { $dynamicRef: "#meta" },
+        properties: {
+          type: "object",
+          additionalProperties: { $dynamicRef: "#meta" },
+          default: {}
+        },
+        patternProperties: {
+          type: "object",
+          additionalProperties: { $dynamicRef: "#meta" },
+          propertyNames: { format: "regex" },
+          default: {}
+        },
+        dependentSchemas: {
+          type: "object",
+          additionalProperties: { $dynamicRef: "#meta" },
+          default: {}
+        },
+        propertyNames: { $dynamicRef: "#meta" },
+        if: { $dynamicRef: "#meta" },
+        then: { $dynamicRef: "#meta" },
+        else: { $dynamicRef: "#meta" },
+        allOf: { $ref: "#/$defs/schemaArray" },
+        anyOf: { $ref: "#/$defs/schemaArray" },
+        oneOf: { $ref: "#/$defs/schemaArray" },
+        not: { $dynamicRef: "#meta" }
+      },
+      $defs: {
+        schemaArray: {
+          type: "array",
+          minItems: 1,
+          items: { $dynamicRef: "#meta" }
+        }
+      }
+    };
+  }
+});
+
+// node_modules/ajv/dist/refs/json-schema-2020-12/meta/unevaluated.json
+var require_unevaluated2 = __commonJS({
+  "node_modules/ajv/dist/refs/json-schema-2020-12/meta/unevaluated.json"(exports, module) {
+    module.exports = {
+      $schema: "https://json-schema.org/draft/2020-12/schema",
+      $id: "https://json-schema.org/draft/2020-12/meta/unevaluated",
+      $vocabulary: {
+        "https://json-schema.org/draft/2020-12/vocab/unevaluated": true
+      },
+      $dynamicAnchor: "meta",
+      title: "Unevaluated applicator vocabulary meta-schema",
+      type: ["object", "boolean"],
+      properties: {
+        unevaluatedItems: { $dynamicRef: "#meta" },
+        unevaluatedProperties: { $dynamicRef: "#meta" }
+      }
+    };
+  }
+});
+
+// node_modules/ajv/dist/refs/json-schema-2020-12/meta/content.json
+var require_content = __commonJS({
+  "node_modules/ajv/dist/refs/json-schema-2020-12/meta/content.json"(exports, module) {
+    module.exports = {
+      $schema: "https://json-schema.org/draft/2020-12/schema",
+      $id: "https://json-schema.org/draft/2020-12/meta/content",
+      $vocabulary: {
+        "https://json-schema.org/draft/2020-12/vocab/content": true
+      },
+      $dynamicAnchor: "meta",
+      title: "Content vocabulary meta-schema",
+      type: ["object", "boolean"],
+      properties: {
+        contentEncoding: { type: "string" },
+        contentMediaType: { type: "string" },
+        contentSchema: { $dynamicRef: "#meta" }
+      }
+    };
+  }
+});
+
+// node_modules/ajv/dist/refs/json-schema-2020-12/meta/core.json
+var require_core3 = __commonJS({
+  "node_modules/ajv/dist/refs/json-schema-2020-12/meta/core.json"(exports, module) {
+    module.exports = {
+      $schema: "https://json-schema.org/draft/2020-12/schema",
+      $id: "https://json-schema.org/draft/2020-12/meta/core",
+      $vocabulary: {
+        "https://json-schema.org/draft/2020-12/vocab/core": true
+      },
+      $dynamicAnchor: "meta",
+      title: "Core vocabulary meta-schema",
+      type: ["object", "boolean"],
+      properties: {
+        $id: {
+          $ref: "#/$defs/uriReferenceString",
+          $comment: "Non-empty fragments not allowed.",
+          pattern: "^[^#]*#?$"
+        },
+        $schema: { $ref: "#/$defs/uriString" },
+        $ref: { $ref: "#/$defs/uriReferenceString" },
+        $anchor: { $ref: "#/$defs/anchorString" },
+        $dynamicRef: { $ref: "#/$defs/uriReferenceString" },
+        $dynamicAnchor: { $ref: "#/$defs/anchorString" },
+        $vocabulary: {
+          type: "object",
+          propertyNames: { $ref: "#/$defs/uriString" },
+          additionalProperties: {
+            type: "boolean"
+          }
+        },
+        $comment: {
+          type: "string"
+        },
+        $defs: {
+          type: "object",
+          additionalProperties: { $dynamicRef: "#meta" }
+        }
+      },
+      $defs: {
+        anchorString: {
+          type: "string",
+          pattern: "^[A-Za-z_][-A-Za-z0-9._]*$"
+        },
+        uriString: {
+          type: "string",
+          format: "uri"
+        },
+        uriReferenceString: {
+          type: "string",
+          format: "uri-reference"
+        }
+      }
+    };
+  }
+});
+
+// node_modules/ajv/dist/refs/json-schema-2020-12/meta/format-annotation.json
+var require_format_annotation = __commonJS({
+  "node_modules/ajv/dist/refs/json-schema-2020-12/meta/format-annotation.json"(exports, module) {
+    module.exports = {
+      $schema: "https://json-schema.org/draft/2020-12/schema",
+      $id: "https://json-schema.org/draft/2020-12/meta/format-annotation",
+      $vocabulary: {
+        "https://json-schema.org/draft/2020-12/vocab/format-annotation": true
+      },
+      $dynamicAnchor: "meta",
+      title: "Format vocabulary meta-schema for annotation results",
+      type: ["object", "boolean"],
+      properties: {
+        format: { type: "string" }
+      }
+    };
+  }
+});
+
+// node_modules/ajv/dist/refs/json-schema-2020-12/meta/meta-data.json
+var require_meta_data = __commonJS({
+  "node_modules/ajv/dist/refs/json-schema-2020-12/meta/meta-data.json"(exports, module) {
+    module.exports = {
+      $schema: "https://json-schema.org/draft/2020-12/schema",
+      $id: "https://json-schema.org/draft/2020-12/meta/meta-data",
+      $vocabulary: {
+        "https://json-schema.org/draft/2020-12/vocab/meta-data": true
+      },
+      $dynamicAnchor: "meta",
+      title: "Meta-data vocabulary meta-schema",
+      type: ["object", "boolean"],
+      properties: {
+        title: {
+          type: "string"
+        },
+        description: {
+          type: "string"
+        },
+        default: true,
+        deprecated: {
+          type: "boolean",
+          default: false
+        },
+        readOnly: {
+          type: "boolean",
+          default: false
+        },
+        writeOnly: {
+          type: "boolean",
+          default: false
+        },
+        examples: {
+          type: "array",
+          items: true
+        }
+      }
+    };
+  }
+});
+
+// node_modules/ajv/dist/refs/json-schema-2020-12/meta/validation.json
+var require_validation2 = __commonJS({
+  "node_modules/ajv/dist/refs/json-schema-2020-12/meta/validation.json"(exports, module) {
+    module.exports = {
+      $schema: "https://json-schema.org/draft/2020-12/schema",
+      $id: "https://json-schema.org/draft/2020-12/meta/validation",
+      $vocabulary: {
+        "https://json-schema.org/draft/2020-12/vocab/validation": true
+      },
+      $dynamicAnchor: "meta",
+      title: "Validation vocabulary meta-schema",
+      type: ["object", "boolean"],
+      properties: {
+        type: {
+          anyOf: [
+            { $ref: "#/$defs/simpleTypes" },
+            {
+              type: "array",
+              items: { $ref: "#/$defs/simpleTypes" },
+              minItems: 1,
+              uniqueItems: true
+            }
+          ]
+        },
+        const: true,
+        enum: {
+          type: "array",
+          items: true
+        },
+        multipleOf: {
+          type: "number",
+          exclusiveMinimum: 0
+        },
+        maximum: {
+          type: "number"
+        },
+        exclusiveMaximum: {
+          type: "number"
+        },
+        minimum: {
+          type: "number"
+        },
+        exclusiveMinimum: {
+          type: "number"
+        },
+        maxLength: { $ref: "#/$defs/nonNegativeInteger" },
+        minLength: { $ref: "#/$defs/nonNegativeIntegerDefault0" },
+        pattern: {
+          type: "string",
+          format: "regex"
+        },
+        maxItems: { $ref: "#/$defs/nonNegativeInteger" },
+        minItems: { $ref: "#/$defs/nonNegativeIntegerDefault0" },
+        uniqueItems: {
+          type: "boolean",
+          default: false
+        },
+        maxContains: { $ref: "#/$defs/nonNegativeInteger" },
+        minContains: {
+          $ref: "#/$defs/nonNegativeInteger",
+          default: 1
+        },
+        maxProperties: { $ref: "#/$defs/nonNegativeInteger" },
+        minProperties: { $ref: "#/$defs/nonNegativeIntegerDefault0" },
+        required: { $ref: "#/$defs/stringArray" },
+        dependentRequired: {
+          type: "object",
+          additionalProperties: {
+            $ref: "#/$defs/stringArray"
+          }
+        }
+      },
+      $defs: {
+        nonNegativeInteger: {
+          type: "integer",
+          minimum: 0
+        },
+        nonNegativeIntegerDefault0: {
+          $ref: "#/$defs/nonNegativeInteger",
+          default: 0
+        },
+        simpleTypes: {
+          enum: ["array", "boolean", "integer", "null", "number", "object", "string"]
+        },
+        stringArray: {
+          type: "array",
+          items: { type: "string" },
+          uniqueItems: true,
+          default: []
+        }
+      }
+    };
+  }
+});
+
+// node_modules/ajv/dist/refs/json-schema-2020-12/index.js
+var require_json_schema_2020_12 = __commonJS({
+  "node_modules/ajv/dist/refs/json-schema-2020-12/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var metaSchema = require_schema();
+    var applicator = require_applicator2();
+    var unevaluated = require_unevaluated2();
+    var content = require_content();
+    var core = require_core3();
+    var format = require_format_annotation();
+    var metadata = require_meta_data();
+    var validation = require_validation2();
+    var META_SUPPORT_DATA = ["/properties"];
+    function addMetaSchema2020($data) {
+      ;
+      [
+        metaSchema,
+        applicator,
+        unevaluated,
+        content,
+        core,
+        with$data(this, format),
+        metadata,
+        with$data(this, validation)
+      ].forEach((sch) => this.addMetaSchema(sch, void 0, false));
+      return this;
+      function with$data(ajv, sch) {
+        return $data ? ajv.$dataMetaSchema(sch, META_SUPPORT_DATA) : sch;
+      }
+    }
+    exports.default = addMetaSchema2020;
+  }
+});
+
+// node_modules/ajv/dist/2020.js
+var require__ = __commonJS({
+  "node_modules/ajv/dist/2020.js"(exports, module) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.MissingRefError = exports.ValidationError = exports.CodeGen = exports.Name = exports.nil = exports.stringify = exports.str = exports._ = exports.KeywordCxt = exports.Ajv2020 = void 0;
+    var core_1 = require_core();
+    var draft2020_1 = require_draft2020();
+    var discriminator_1 = require_discriminator();
+    var json_schema_2020_12_1 = require_json_schema_2020_12();
+    var META_SCHEMA_ID = "https://json-schema.org/draft/2020-12/schema";
+    var Ajv20202 = class extends core_1.default {
+      constructor(opts = {}) {
+        super({
+          ...opts,
+          dynamicRef: true,
+          next: true,
+          unevaluated: true
+        });
+      }
+      _addVocabularies() {
+        super._addVocabularies();
+        draft2020_1.default.forEach((v) => this.addVocabulary(v));
+        if (this.opts.discriminator)
+          this.addKeyword(discriminator_1.default);
+      }
+      _addDefaultMetaSchema() {
+        super._addDefaultMetaSchema();
+        const { $data, meta } = this.opts;
+        if (!meta)
+          return;
+        json_schema_2020_12_1.default.call(this, $data);
+        this.refs["http://json-schema.org/schema"] = META_SCHEMA_ID;
+      }
+      defaultMeta() {
+        return this.opts.defaultMeta = super.defaultMeta() || (this.getSchema(META_SCHEMA_ID) ? META_SCHEMA_ID : void 0);
+      }
+    };
+    exports.Ajv2020 = Ajv20202;
+    module.exports = exports = Ajv20202;
+    module.exports.Ajv2020 = Ajv20202;
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.default = Ajv20202;
+    var validate_1 = require_validate();
+    Object.defineProperty(exports, "KeywordCxt", { enumerable: true, get: function() {
+      return validate_1.KeywordCxt;
+    } });
+    var codegen_1 = require_codegen();
+    Object.defineProperty(exports, "_", { enumerable: true, get: function() {
+      return codegen_1._;
+    } });
+    Object.defineProperty(exports, "str", { enumerable: true, get: function() {
+      return codegen_1.str;
+    } });
+    Object.defineProperty(exports, "stringify", { enumerable: true, get: function() {
+      return codegen_1.stringify;
+    } });
+    Object.defineProperty(exports, "nil", { enumerable: true, get: function() {
+      return codegen_1.nil;
+    } });
+    Object.defineProperty(exports, "Name", { enumerable: true, get: function() {
+      return codegen_1.Name;
+    } });
+    Object.defineProperty(exports, "CodeGen", { enumerable: true, get: function() {
+      return codegen_1.CodeGen;
+    } });
+    var validation_error_1 = require_validation_error();
+    Object.defineProperty(exports, "ValidationError", { enumerable: true, get: function() {
+      return validation_error_1.default;
+    } });
+    var ref_error_1 = require_ref_error();
+    Object.defineProperty(exports, "MissingRefError", { enumerable: true, get: function() {
+      return ref_error_1.default;
+    } });
+  }
+});
+
+// packages/installer/src/setup.ts
+import path4 from "node:path";
+import { homedir } from "node:os";
+import { readFile as readFile2, rm as rm2 } from "node:fs/promises";
+
+// packages/installer/src/native.ts
+import path3 from "node:path";
+import { cp, mkdir, readFile, rename, rm, chmod, realpath as realpath2 } from "node:fs/promises";
+
+// packages/installer/src/package-source.ts
+var import__ = __toESM(require__(), 1);
+import path from "node:path";
+import { lstat, realpath } from "node:fs/promises";
+async function rejectLink(file) {
+  if ((await lstat(file)).isSymbolicLink())
+    throw new Fault("SYMLINK_NOT_ALLOWED", "Source and bundle inventories reject symlinks.", 2);
+}
+async function pluginAt(root) {
+  if (await exists(path.join(root, ".codex-plugin/plugin.json")) || await exists(path.join(root, "plugin.json")))
+    return root;
+  const plugins = path.join(root, "plugins");
+  if (!await exists(plugins)) return;
+  await rejectLink(plugins);
+  const plugin = path.join(plugins, "apexrest-apex");
+  if (!await exists(plugin)) return;
+  await rejectLink(plugin);
+  if (await exists(path.join(plugin, ".codex-plugin/plugin.json")) || await exists(path.join(plugin, "plugin.json")))
+    return plugin;
+}
+async function resolveNativePlugin(source) {
+  const candidates = source ? [path.resolve(source)] : [path.resolve(resourceRoot(), ".."), path.resolve(resourceRoot(), "../codex-compat")];
+  for (const candidate of candidates) {
+    if (!await exists(candidate)) continue;
+    const plugin = await pluginAt(await realpath(candidate));
+    if (plugin) return plugin;
+  }
+  throw new Fault(
+    "INVALID_PACKAGE",
+    "No APEXREST plugin bundle found. Set the source to a built plugin directory or its marketplace directory.",
+    2
+  );
+}
+var nativeMarketplace = {
+  name: "apexrest",
+  interface: { displayName: "APEXREST" },
+  plugins: [
+    {
+      name: "apexrest-apex",
+      source: { source: "local", path: "./plugins/apexrest-apex" },
+      policy: { installation: "AVAILABLE", authentication: "ON_USE", products: ["codex"] },
+      category: "Productivity"
+    }
+  ]
+};
+async function validateNative(source) {
+  const root = await resolveNativePlugin(source);
+  await inventory(root);
+  const portable = await exists(path.join(root, "plugin.json"));
+  const manifest = await readJson(
+    path.join(root, portable ? "plugin.json" : ".codex-plugin/plugin.json")
+  );
+  if (manifest.name !== "apexrest-apex" || !/^\d+\.\d+\.\d+(?:-[\w.-]+)?(?:\+[\w.-]+)?$/.test(manifest.version))
+    throw new Fault("INVALID_PACKAGE", "Invalid plugin identity or version.", 2);
+  const mcp = await readJson(path.join(root, portable ? "mcp.json" : ".mcp.json"));
+  if (!mcp.mcpServers.apexrest || Object.keys(mcp.mcpServers).length !== 1)
+    throw new Fault("INVALID_PACKAGE", "Package must expose exactly its own MCP server.", 2);
+  if (portable) {
+    const ajv = new import__.Ajv2020({ strict: false });
+    for (const [file, value] of [
+      ["plugin", manifest],
+      ["mcp", mcp]
+    ])
+      if (!ajv.validate(
+        await readJson(path.join(resourceRoot(), `schemas/vendor/${file}.schema.json`)),
+        value
+      ))
+        throw new Fault("MANIFEST_SCHEMA_INVALID", ajv.errorsText(), 2);
+  } else if (manifest.mcpServers !== "./.mcp.json")
+    throw new Fault("MANIFEST_SCHEMA_INVALID", "Compatibility manifest must use the companion .mcp.json.", 2);
+  for (const file of ["runtime/mcp.mjs", "runtime/apexrest.mjs", "skills/apexrest-setup/SKILL.md"])
+    if (!await exists(path.join(root, file))) throw new Fault("INCOMPLETE_PACKAGE", `Missing ${file}`, 2);
+  return { status: "valid", profile: portable ? "portable" : "codex-compat", version: manifest.version };
+}
+
+// packages/installer/src/registration.ts
+import path2 from "node:path";
+async function checkCodex(codexHome, codex = "codex") {
+  const result = await runProcess({
+    executable: codex,
+    args: ["--version"],
+    cwd: process.cwd(),
+    env: { ...process.env, CODEX_HOME: codexHome },
+    timeoutMs: 1e4
+  });
+  if (result.code !== 0 || result.timedOut || result.truncated || !/^codex-cli\s+\d+\./.test(result.stdout))
+    throw new Fault(
+      "DEPENDENCY_MISSING",
+      "A working Codex CLI is required for plugin setup. Install Codex, then preview setup again.",
+      3,
+      "dependency_missing"
+    );
+}
+function codexInvoke(codexHome, cwd, codex = "codex") {
+  return async (args) => {
+    const result = await runProcess({
+      executable: codex,
+      args,
+      cwd,
+      env: { ...process.env, CODEX_HOME: codexHome },
+      timeoutMs: 6e4
+    });
+    if (result.timedOut || result.cancelled || result.truncated || result.code === null)
+      throw new Fault(
+        "CODEX_REGISTRATION_UNKNOWN",
+        "Codex did not return a complete result. Inspect the registration before retrying.",
+        6,
+        "outcome_unknown"
+      );
+    if (result.code !== 0)
+      throw new Fault("CODEX_REGISTRATION_FAILED", result.stderr || result.stdout, 3, "blocked");
+    try {
+      return JSON.parse(result.stdout);
+    } catch {
+      throw new Fault(
+        "CODEX_REGISTRATION_UNKNOWN",
+        "Codex returned an invalid registration response.",
+        6,
+        "outcome_unknown"
+      );
+    }
+  };
+}
+async function listMarketplaces(invoke) {
+  const result = await invoke(["plugin", "marketplace", "list", "--json"]);
+  if (!Array.isArray(result.marketplaces) || result.marketplaces.some((m) => typeof m.name !== "string" || typeof m.root !== "string"))
+    throw new Fault(
+      "CODEX_REGISTRATION_UNKNOWN",
+      "Codex returned an invalid marketplace listing.",
+      6,
+      "outcome_unknown"
+    );
+  return result.marketplaces;
+}
+async function inspectRegistration(markets, home, codexHome, destination) {
+  const entries = markets.filter((m) => m.name === "apexrest");
+  const conflict = (reason) => {
+    throw new Fault(
+      "MARKETPLACE_OWNERSHIP_CONFLICT",
+      `Cannot update the apexrest marketplace at ${entries[0]?.root ?? "(unknown)"} in ${codexHome}: ${reason} It was left unchanged. Select another Codex profile directory in Advanced options, or review this registration in Codex.`,
+      5,
+      "conflict"
+    );
+  };
+  if (entries.length > 1) conflict("more than one registration was found.");
+  const existing = entries[0];
+  if (!existing) return { action: "install", fingerprint: hash(canonical(markets)), markets };
+  let version, files;
+  try {
+    if (existing.marketplaceSource && existing.marketplaceSource.sourceType !== "local")
+      conflict("automatic migration supports a local APEXREST marketplace only.");
+    const metadata = await readJson(path2.join(existing.root, ".agents/plugins/marketplace.json"));
+    if (canonical(metadata) !== canonical(nativeMarketplace))
+      conflict("its metadata does not identify the dedicated APEXREST marketplace.");
+    const plugin = await resolveNativePlugin(existing.root);
+    if (path2.relative(existing.root, plugin).split(path2.sep).join("/") !== "plugins/apexrest-apex")
+      conflict("its plugin source is not the expected local bundle.");
+    version = (await validateNative(plugin)).version;
+    files = await inventory(plugin);
+  } catch (error) {
+    if (error instanceof Fault && error.code === "MARKETPLACE_OWNERSHIP_CONFLICT") throw error;
+    conflict("its APEXREST plugin bundle could not be validated.");
+  }
+  const receipt = path2.join(home, "installation.json");
+  const previous = await exists(receipt) ? await readJson(receipt) : void 0;
+  const managed = existing.root === destination || existing.root === previous?.destination && previous?.codexHome === codexHome;
+  return {
+    action: managed ? "update" : "adopt",
+    previousRoot: existing.root,
+    previousVersion: version,
+    fingerprint: hash(canonical({ markets, files })),
+    markets
+  };
+}
+
+// packages/installer/src/native.ts
+async function installNative(r) {
+  const source = await resolveNativePlugin(r.source);
+  const payload = Object.fromEntries(
+    Object.entries(await inventory(source)).map(([file, digest2]) => [
+      "plugins/apexrest-apex/" + file,
+      digest2
+    ])
+  );
+  payload[".agents/plugins/marketplace.json"] = hash(JSON.stringify(nativeMarketplace, null, 2) + "\n");
+  const copyDigest = hash(canonical(payload));
+  const sourceMcpFile = await exists(path3.join(source, "plugin.json")) ? "mcp.json" : ".mcp.json";
+  const sourceMcp = await readJson(path3.join(source, sourceMcpFile));
+  const sourceServer = sourceMcp.mcpServers.apexrest;
+  if (!sourceServer) throw new Fault("INVALID_PACKAGE", "Native package has no apexrest MCP server.", 2);
+  sourceServer.command = "node";
+  sourceServer.args = ["runtime/mcp.mjs"];
+  delete sourceServer.env;
+  payload["plugins/apexrest-apex/" + sourceMcpFile] = hash(JSON.stringify(sourceMcp, null, 2) + "\n");
+  const digest = hash(canonical(payload));
+  if (!r.dryRun) {
+    await mkdir(r.home, { recursive: true, mode: 448 });
+    await mkdir(r.codexHome, { recursive: true, mode: 448 });
+  }
+  const home = await exists(r.home) ? await realpath2(r.home) : path3.resolve(r.home);
+  const codexHome = await exists(r.codexHome) ? await realpath2(r.codexHome) : path3.resolve(r.codexHome);
+  const node = r.node ?? process.execPath;
+  const destination = path3.join(home, "native", hash(canonical({ sourceDigest: digest, node, home })));
+  const invoke = codexInvoke(codexHome, await exists(home) ? home : process.cwd(), r.codex);
+  if (!await exists(codexHome)) await checkCodex(codexHome, r.codex);
+  const inspect = async () => inspectRegistration(
+    await exists(codexHome) ? await listMarketplaces(invoke) : [],
+    home,
+    codexHome,
+    destination
+  );
+  const registration = await inspect();
+  if (r.expectedRegistration && r.expectedRegistration !== registration.fingerprint)
+    throw new Fault(
+      "MARKETPLACE_CHANGED",
+      "The Codex registration changed after setup preflight. Review setup again.",
+      5,
+      "conflict"
+    );
+  if (r.dryRun)
+    return {
+      state: "planned",
+      source,
+      scope: "apexrest-plugin-only",
+      sourceDigest: digest,
+      destination,
+      node,
+      codexHome,
+      registration
+    };
+  return withLock(path3.join(home, "install.lock"), async () => {
+    await mkdir(codexHome, { recursive: true, mode: 448 });
+    const config = path3.join(codexHome, "config.toml");
+    const stamp = Date.now();
+    const configBackup = path3.join(home, "config-before-install-" + stamp + ".toml");
+    if (await exists(config)) await cp(config, configBackup);
+    if (!await exists(destination)) {
+      const staging = destination + ".staging";
+      await rm(staging, { recursive: true, force: true });
+      await mkdir(staging, { recursive: true, mode: 448 });
+      await mkdir(path3.join(staging, "plugins"), { recursive: true });
+      await cp(source, path3.join(staging, "plugins/apexrest-apex"), { recursive: true });
+      await writeJson(path3.join(staging, ".agents/plugins/marketplace.json"), nativeMarketplace);
+      if (hash(canonical(await inventory(staging))) !== copyDigest)
+        throw new Fault("PACKAGE_COPY_INVALID", "Native package copy changed.", 5);
+      await rename(staging, destination);
+    }
+    const root = path3.join(destination, "plugins/apexrest-apex");
+    const portable = await exists(path3.join(root, "plugin.json"));
+    const mcpPath = path3.join(root, portable ? "mcp.json" : ".mcp.json");
+    const mcp = JSON.parse(await readFile(mcpPath, "utf8"));
+    const server = mcp.mcpServers.apexrest;
+    if (!server) throw new Fault("INVALID_PACKAGE", "Native package has no apexrest MCP server.", 2);
+    server.command = node;
+    server.args = [path3.join(root, "runtime/mcp.mjs")];
+    server.env = { APEXREST_HOME: home };
+    await writeJson(mcpPath, mcp);
+    const current = await inspect();
+    if (current.fingerprint !== registration.fingerprint)
+      throw new Fault(
+        "MARKETPLACE_CHANGED",
+        "The Codex registration changed during setup. Nothing was re-registered; review setup again.",
+        5,
+        "conflict"
+      );
+    const transition = path3.join(home, "registration-before-install-" + stamp + ".json");
+    const previousListing = registration.previousRoot ? await invoke(["plugin", "list", "--marketplace", "apexrest", "--json"]) : void 0;
+    const previousPlugin = previousListing?.installed?.find((plugin) => plugin.pluginId === "apexrest-apex@apexrest");
+    const record = { registration, destination, codexHome, configBackup, previousListing };
+    await writeJson(transition, { status: "prepared", ...record });
+    let marketplace, installed, listing;
+    const replacing = registration.previousRoot && registration.previousRoot !== destination;
+    try {
+      if (replacing) await invoke(["plugin", "marketplace", "remove", "apexrest", "--json"]);
+      marketplace = await invoke(["plugin", "marketplace", "add", destination, "--json"]);
+      installed = await invoke(["plugin", "add", "apexrest-apex@apexrest", "--json"]);
+      const cached = installed.installedPath;
+      if (!cached || canonical(await inventory(await contained(codexHome, cached))) !== canonical(await inventory(root)))
+        throw new Fault("NATIVE_CACHE_MISMATCH", "Codex did not install the reviewed plugin files.", 5);
+      listing = await invoke(["plugin", "list", "--marketplace", "apexrest", "--json"]);
+      if (!listing.installed?.some(
+        (plugin) => plugin.pluginId === "apexrest-apex@apexrest" && plugin.enabled
+      ))
+        throw new Fault(
+          "NATIVE_PLUGIN_NOT_ENABLED",
+          "Codex did not enable the installed APEXREST plugin.",
+          3
+        );
+      const after = await listMarketplaces(invoke);
+      if (after.find((m) => m.name === "apexrest")?.root !== destination || canonical(after.filter((m) => m.name !== "apexrest")) !== canonical(registration.markets.filter((m) => m.name !== "apexrest")))
+        throw new Fault(
+          "MARKETPLACE_CHANGED",
+          "Codex registration verification failed. Inspect the saved registration record before retrying.",
+          5,
+          "conflict"
+        );
+      await writeJson(transition, { status: "registered", ...record });
+    } catch (error) {
+      let recovery = "needs-review";
+      let unknown = error instanceof Fault && error.status === "outcome_unknown";
+      if (replacing && !(error instanceof Fault && error.status === "outcome_unknown")) {
+        try {
+          const after = await listMarketplaces(invoke);
+          const selected = after.find((m) => m.name === "apexrest");
+          if (canonical(after.filter((m) => m.name !== "apexrest")) !== canonical(registration.markets.filter((m) => m.name !== "apexrest")) || (await inspectRegistration(registration.markets, home, codexHome, destination)).fingerprint !== registration.fingerprint)
+            throw new Error("The prior registration or source changed externally.");
+          if (selected && selected.root !== destination && selected.root !== registration.previousRoot)
+            throw new Error("Registration changed externally.");
+          if (selected?.root === destination)
+            await invoke(["plugin", "marketplace", "remove", "apexrest", "--json"]);
+          if (selected?.root !== registration.previousRoot)
+            await invoke(["plugin", "marketplace", "add", registration.previousRoot, "--json"]);
+          if (previousPlugin?.enabled) {
+            const restored = await invoke(["plugin", "add", "apexrest-apex@apexrest", "--json"]);
+            const previousRoot = await resolveNativePlugin(registration.previousRoot);
+            if (!restored.installedPath || canonical(await inventory(await contained(codexHome, restored.installedPath))) !== canonical(await inventory(previousRoot)))
+              throw new Error("The previous cached plugin could not be verified.");
+          }
+          if ((await listMarketplaces(invoke)).find((m) => m.name === "apexrest")?.root !== registration.previousRoot)
+            throw new Error("The previous marketplace could not be verified.");
+          recovery = previousPlugin?.enabled ? "previous-registration-restored" : "previous-marketplace-restored; plugin-state-needs-review";
+        } catch (recoveryError) {
+          unknown ||= recoveryError instanceof Fault && recoveryError.status === "outcome_unknown";
+          recovery = unknown ? "outcome-unknown" : "needs-review";
+        }
+      } else if (error instanceof Fault && error.status === "outcome_unknown") recovery = "outcome-unknown";
+      await writeJson(transition, { status: "failed", recovery, ...record });
+      throw new Fault(
+        error instanceof Fault ? error.code : "CODEX_REGISTRATION_FAILED",
+        `${error instanceof Error ? error.message : "Registration failed."} Recovery: ${recovery}. Record: ${transition}`,
+        unknown ? 6 : error instanceof Fault ? error.exitCode : 3,
+        unknown ? "outcome_unknown" : error instanceof Fault ? error.status : "blocked"
+      );
+    }
+    const state = {
+      schemaVersion: 1,
+      state: "registered",
+      sourceDigest: digest,
+      destination,
+      root,
+      node,
+      codexHome,
+      marketplace,
+      installed,
+      listing,
+      registration: { ...registration, transition },
+      actions: ["CODEX_RELOAD_REQUIRED", "NATIVE_HOST_VERIFICATION_REQUIRED"]
+    };
+    await writeJson(path3.join(home, "installation.json"), state);
+    const cli = path3.join(root, "runtime/apexrest.mjs");
+    const quote = (value) => "'" + value.replaceAll("'", `'"'"'`) + "'";
+    await mkdir(path3.join(home, "bin"), { recursive: true });
+    if (process.platform === "win32") {
+      const ps = (value) => "'" + value.replaceAll("'", "''") + "'";
+      await atomicWrite(
+        path3.join(home, "bin/apexrest.ps1"),
+        `$env:APEXREST_HOME=${ps(home)}
+& ${ps(node)} ${ps(cli)} @args
+exit $LASTEXITCODE
+`
+      );
+    } else {
+      const launcher = path3.join(home, "bin/apexrest");
+      await atomicWrite(
+        launcher,
+        `#!/bin/sh
+export APEXREST_HOME=${quote(home)}
+exec ${quote(node)} ${quote(cli)} "$@"
+`
+      );
+      await chmod(launcher, 448);
+    }
+    await writeJson(transition, { status: "completed", ...record });
+    return state;
+  });
+}
+async function installationState(home) {
+  return readJson(path3.join(home, "installation.json"));
+}
+
+// packages/installer/src/setup.ts
+async function setup(input) {
+  const text = (key) => input[key];
+  const home = path4.resolve(
+    text("home") ?? (input.scope === "project" ? path4.join(text("project") ?? process.cwd(), ".apexrest/managed") : managedHome())
+  );
+  if (input.scope === "project") {
+    await requireTrust(text("project") ?? process.cwd());
+    throw new Fault(
+      "PROJECT_HOST_SCOPE_UNAVAILABLE",
+      "Codex 0.154.0 plugin add enables in the selected user profile. Use --scope user with a dedicated --codex-home until project-only enablement is verified.",
+      3,
+      "blocked"
+    );
+  }
+  const source = await resolveNativePlugin(text("from"));
+  const validation = await validateNative(source);
+  if (text("version") && text("version") !== validation.version)
+    throw new Fault(
+      "VERSION_MISMATCH",
+      "Requested version does not match the supplied immutable package.",
+      2
+    );
+  const codexHome = path4.resolve(
+    text("codexHome") ?? process.env.CODEX_HOME ?? path4.join(homedir(), ".codex")
+  );
+  const request = {
+    home,
+    ...text("cacheDir") ? { cacheDir: text("cacheDir") } : {},
+    offline: Boolean(input.offline),
+    dryRun: Boolean(input.dryRun),
+    yes: Boolean(input.yes),
+    nonInteractive: Boolean(input.nonInteractive),
+    acceptOracleLicense: Boolean(input.acceptOracleLicense),
+    skipBrowser: Boolean(input.skipBrowser),
+    installOsDeps: Boolean(input.installOsDeps)
+  };
+  const existingRuntime = await runtimeState(home);
+  const nativePlan = await installNative({
+    source,
+    home,
+    codexHome,
+    dryRun: true,
+    node: existingRuntime.node ?? process.execPath
+  });
+  if (input.dryRun)
+    return {
+      status: "planned",
+      package: validation,
+      toolchain: input.nativeOnly ? { status: "not-requested", components: {} } : await new ToolchainService().plan(request),
+      native: nativePlan
+    };
+  if (!input.yes)
+    throw new Fault(
+      "SETUP_APPROVAL_REQUIRED",
+      "Use --dry-run to review, then --yes for technical installation steps.",
+      4,
+      "needs-user-action"
+    );
+  const toolchain = input.nativeOnly ? { status: "not-requested", components: {} } : await new ToolchainService().apply(request);
+  const runtime = await runtimeState(home);
+  const native = await installNative({
+    source,
+    home,
+    codexHome,
+    node: runtime.node ?? process.execPath,
+    expectedRegistration: nativePlan.registration.fingerprint
+  });
+  if (!("root" in native)) throw new Fault("INSTALL_NOT_COMPLETED", "Native install remained a plan.", 3);
+  const mcp = JSON.parse(
+    await readFile2(
+      path4.join(native.root, validation.profile === "portable" ? "mcp.json" : ".mcp.json"),
+      "utf8"
+    )
+  );
+  const env = Object.fromEntries(
+    Object.entries(process.env).filter((entry) => entry[1] !== void 0)
+  );
+  env.APEXREST_HOME = home;
+  const client = new Client({ name: "apexrest-installer", version: VERSION });
+  const transport = new StdioClientTransport({ ...mcp.mcpServers.apexrest, env, stderr: "pipe" });
+  try {
+    await client.connect(transport);
+    await client.listTools();
+  } finally {
+    await client.close();
+  }
+  const result = {
+    schemaVersion: 1,
+    status: "needs-user-action",
+    components: {
+      ..."components" in toolchain ? toolchain.components : {},
+      nativePlugin: "registered",
+      mcp: "verified",
+      database: "not-configured"
+    },
+    actions: [{ code: "CODEX_RELOAD_REQUIRED" }, { code: "DATABASE_CONNECTION_REQUIRED" }],
+    native,
+    toolchain
+  };
+  await writeJson(path4.join(home, "setup-result.json"), result);
+  return result;
+}
+async function uninstallNative(home, keepRuntime) {
+  const state = await installationState(home);
+  const markets = await runProcess({
+    executable: "codex",
+    args: ["plugin", "marketplace", "list", "--json"],
+    cwd: home,
+    env: { ...process.env, CODEX_HOME: state.codexHome },
+    timeoutMs: 3e4
+  });
+  const owned = markets.code === 0 && JSON.parse(markets.stdout).marketplaces.some(
+    (m) => m.name === "apexrest" && m.root === state.destination
+  );
+  if (!owned)
+    throw new Fault(
+      "MARKETPLACE_OWNERSHIP_CONFLICT",
+      "Current marketplace no longer belongs to this installation; nothing was removed.",
+      5
+    );
+  const result = await runProcess({
+    executable: "codex",
+    args: ["plugin", "remove", "apexrest-apex@apexrest"],
+    cwd: home,
+    env: { ...process.env, CODEX_HOME: state.codexHome },
+    timeoutMs: 3e4
+  });
+  if (result.code !== 0) throw new Fault("UNINSTALL_FAILED", result.stderr, 3);
+  const removal = await runProcess({
+    executable: "codex",
+    args: ["plugin", "marketplace", "remove", "apexrest"],
+    cwd: home,
+    env: { ...process.env, CODEX_HOME: state.codexHome },
+    timeoutMs: 3e4
+  });
+  if (removal.code !== 0) throw new Fault("MARKETPLACE_REMOVE_FAILED", removal.stderr, 3);
+  const listing = await runProcess({
+    executable: "codex",
+    args: ["plugin", "list", "--json"],
+    cwd: home,
+    env: { ...process.env, CODEX_HOME: state.codexHome },
+    timeoutMs: 3e4
+  });
+  if (listing.code !== 0 || listing.stdout.includes("apexrest-apex@apexrest"))
+    throw new Fault("UNINSTALL_UNCONFIRMED", "Codex still lists this plugin.", 3);
+  const destination = await contained(home, state.destination);
+  if (!keepRuntime) await rm2(destination, { recursive: true, force: true });
+  await writeJson(path4.join(home, "uninstalled.json"), {
+    at: (/* @__PURE__ */ new Date()).toISOString(),
+    keepRuntime,
+    sharedRuntimePreserved: true
+  });
+  return {
+    status: "uninstalled",
+    projectsPreserved: true,
+    backupsPreserved: true,
+    credentialsPreserved: true,
+    sharedRuntimePreserved: true
+  };
+}
+export {
+  setup,
+  uninstallNative,
+  validateNative
+};