@benjamolina/pi-antigravity-guard 0.4.1 → 0.4.3

package/README.md

@@ -18,7 +18,7 @@ All seven rows below are registered for text. The exact `antigravity-gemini-3.8-
 
 | Public ID | Exposed Pi levels | Tool state | Admission |
 |---|---|---|---|
-| `antigravity-gemini-3.8-flash` | off, low, medium, high | Enabled (off) | pi-json-tool-loop/gemini-3.8-flash-off-v1 |
+| `antigravity-gemini-3.8-flash` | off, low, medium, high | Enabled (off, low, medium, high) | pi-json-tool-loop/gemini-3.8-flash-off-v1 |
 | `antigravity-gemini-3.7-flash` | off, low, medium, high | Disabled | missing-direct-evidence |
 | `antigravity-gemini-3.6-flash` | off, low, medium, high | Disabled | missing-direct-evidence |
 | `antigravity-gemini-3.1-pro` | off, low, high | Disabled | missing-direct-evidence |
@@ -38,7 +38,7 @@ Maintainers can run `npm run build:pi` followed by `npx tsx scripts/pi-tool-loop
 
 Tool-bearing requests are never silently downgraded to text. When an exact route is eventually enabled, declarations are retained in order and omitted or `auto` choice serializes as `AUTO`; explicit `none` serializes as `NONE`. Forced, required, named, unknown, and constrained-sampling choices are rejected before transport.
 
-Schemas must use the documented strict object-rooted subset. Unsupported keywords, references, unions, lossy constraints, empty objects, and oversized input are rejected rather than cleaned. Tool results must match the exact call ID and name, remain text-only, and are replayed in assistant source-call order; image-bearing or ambiguous results are rejected. A missing persisted result uses the documented failed response only during context reconstruction.
+Only the evidence-enabled Gemini 3.8 Flash `off` route uses the `parametersJsonSchema` profile. Its hermetically verified preflight preserves ordinary JSON Schema constraints and JSON values in canonical immutable output, including safe local RFC 6901 `$ref` expansion (`#` and `#/...`) with resolved definitions removed. External, malformed, unresolved, cyclic, or otherwise unsafe references fail closed before transport. This is local serialization and safety evidence, not direct live backend acceptance of constrained or reference-based schemas. Tool results must match the exact call ID and name, remain text-only, and are replayed in assistant source-call order; image-bearing or ambiguous results are rejected. A missing persisted result uses the documented failed response only during context reconstruction.
 
 ## Text catalog limits and safety
 

package/dist/catalog.d.ts

@@ -7,6 +7,8 @@ export interface ToolEvidenceRef {
     readonly reasoning: StandardReasoningLevel;
     readonly wireModel: string;
 }
+export declare const GEMINI_PARAMETERS_JSON_SCHEMA_PROFILE: "gemini-parameters-json-schema";
+export type ToolSchemaProfile = typeof GEMINI_PARAMETERS_JSON_SCHEMA_PROFILE;
 export type ToolCapability = {
     readonly state: "disabled";
     readonly contractRevision: 1;
@@ -18,6 +20,7 @@ export type ToolCapability = {
 } | {
     readonly state: "enabled";
     readonly contractRevision: 1;
+    readonly schemaProfile: ToolSchemaProfile;
     readonly fixtureEvidence: ToolEvidenceRef;
     readonly directEvidence: ToolEvidenceRef;
 };
@@ -75,37 +78,37 @@ declare const CATALOG: readonly [{
     };
     readonly routes: {
         readonly off: {
-            readonly wireModel: "gemini-3.8-flash-tiered";
+            readonly wireModel: "gemini-3.8-flash-low";
             readonly thinking: {
-                readonly kind: "native-level";
-                readonly thinkingLevel: "low";
+                readonly kind: "budget";
+                readonly budget: 0;
                 readonly includeThoughts: false;
             };
             readonly tools: ToolCapability;
         };
         readonly low: {
-            readonly wireModel: "gemini-3.8-flash-tiered";
+            readonly wireModel: "gemini-3.8-flash-low";
             readonly thinking: {
-                readonly kind: "native-level";
-                readonly thinkingLevel: "low";
+                readonly kind: "budget";
+                readonly budget: 1000;
                 readonly includeThoughts: true;
             };
             readonly tools: ToolCapability;
         };
         readonly medium: {
-            readonly wireModel: "gemini-3.8-flash-tiered";
+            readonly wireModel: "gemini-3.8-flash-medium";
             readonly thinking: {
-                readonly kind: "native-level";
-                readonly thinkingLevel: "medium";
+                readonly kind: "budget";
+                readonly budget: 4000;
                 readonly includeThoughts: true;
             };
             readonly tools: ToolCapability;
         };
         readonly high: {
-            readonly wireModel: "gemini-3.8-flash-tiered";
+            readonly wireModel: "gemini-3.8-flash-high";
             readonly thinking: {
-                readonly kind: "native-level";
-                readonly thinkingLevel: "high";
+                readonly kind: "budget";
+                readonly budget: -1;
                 readonly includeThoughts: true;
             };
             readonly tools: ToolCapability;
@@ -402,7 +405,7 @@ type Catalog = typeof CATALOG;
 export type AntigravityPublicModelId = Catalog[number]["publicId"];
 export type AntigravityWireModelId = Catalog[number]["routes"][keyof Catalog[number]["routes"]]["wireModel"];
 /** Constructs deterministic capability data for hermetic serializer tests only. */
-export declare function createEnabledToolCapability(evidence: ToolEvidenceRef): Extract<ToolCapability, {
+export declare function createEnabledToolCapability(evidence: ToolEvidenceRef, schemaProfile?: ToolSchemaProfile): Extract<ToolCapability, {
     readonly state: "enabled";
 }>;
 export declare function defineCatalog<T extends readonly {

package/dist/catalog.js

@@ -1,4 +1,5 @@
 const ANSWER_RESERVE = 1024;
+export const GEMINI_PARAMETERS_JSON_SCHEMA_PROFILE = "gemini-parameters-json-schema";
 const CATALOG = freeze(defineCatalog([{
         publicId: "antigravity-gemini-3.8-flash",
         descriptor: {
@@ -8,10 +9,10 @@ const CATALOG = freeze(defineCatalog([{
             maxTokens: 65_536,
         },
         routes: {
-            off: { wireModel: "gemini-3.8-flash-tiered", thinking: { kind: "native-level", thinkingLevel: "low", includeThoughts: false }, tools: enabled({ record: "pi-json-tool-loop", revision: "gemini-3.8-flash-off-v1", publicModelId: "antigravity-gemini-3.8-flash", reasoning: "off", wireModel: "gemini-3.8-flash-tiered" }) },
-            low: { wireModel: "gemini-3.8-flash-tiered", thinking: { kind: "native-level", thinkingLevel: "low", includeThoughts: true }, tools: disabled("missing-direct-evidence") },
-            medium: { wireModel: "gemini-3.8-flash-tiered", thinking: { kind: "native-level", thinkingLevel: "medium", includeThoughts: true }, tools: disabled("missing-direct-evidence") },
-            high: { wireModel: "gemini-3.8-flash-tiered", thinking: { kind: "native-level", thinkingLevel: "high", includeThoughts: true }, tools: disabled("missing-direct-evidence") },
+            off: { wireModel: "gemini-3.8-flash-low", thinking: { kind: "budget", budget: 0, includeThoughts: false }, tools: enabled({ record: "pi-json-tool-loop", revision: "gemini-3.8-flash-off-v1", publicModelId: "antigravity-gemini-3.8-flash", reasoning: "off", wireModel: "gemini-3.8-flash-low" }, GEMINI_PARAMETERS_JSON_SCHEMA_PROFILE) },
+            low: { wireModel: "gemini-3.8-flash-low", thinking: { kind: "budget", budget: 1000, includeThoughts: true }, tools: enabled({ record: "pi-json-tool-loop", revision: "gemini-3.8-flash-low-v1", publicModelId: "antigravity-gemini-3.8-flash", reasoning: "low", wireModel: "gemini-3.8-flash-low" }, GEMINI_PARAMETERS_JSON_SCHEMA_PROFILE) },
+            medium: { wireModel: "gemini-3.8-flash-medium", thinking: { kind: "budget", budget: 4000, includeThoughts: true }, tools: enabled({ record: "pi-json-tool-loop", revision: "gemini-3.8-flash-medium-v1", publicModelId: "antigravity-gemini-3.8-flash", reasoning: "medium", wireModel: "gemini-3.8-flash-medium" }, GEMINI_PARAMETERS_JSON_SCHEMA_PROFILE) },
+            high: { wireModel: "gemini-3.8-flash-high", thinking: { kind: "budget", budget: -1, includeThoughts: true }, tools: enabled({ record: "pi-json-tool-loop", revision: "gemini-3.8-flash-high-v1", publicModelId: "antigravity-gemini-3.8-flash", reasoning: "high", wireModel: "gemini-3.8-flash-high" }, GEMINI_PARAMETERS_JSON_SCHEMA_PROFILE) },
         },
         replay: { kind: "same-public-model" },
         response: { kind: "gemini-envelope", family: "gemini" },
@@ -109,12 +110,12 @@ const lookup = new Map(CATALOG.map((entry) => [entry.publicId, entry]));
 function disabled(reason) {
     return { state: "disabled", contractRevision: 1, reason };
 }
-function enabled(evidence) {
-    return { state: "enabled", contractRevision: 1, fixtureEvidence: evidence, directEvidence: evidence };
+function enabled(evidence, schemaProfile = GEMINI_PARAMETERS_JSON_SCHEMA_PROFILE) {
+    return { state: "enabled", contractRevision: 1, schemaProfile, fixtureEvidence: evidence, directEvidence: evidence };
 }
 /** Constructs deterministic capability data for hermetic serializer tests only. */
-export function createEnabledToolCapability(evidence) {
-    return freeze({ state: "enabled", contractRevision: 1, fixtureEvidence: evidence, directEvidence: evidence });
+export function createEnabledToolCapability(evidence, schemaProfile = GEMINI_PARAMETERS_JSON_SCHEMA_PROFILE) {
+    return freeze({ state: "enabled", contractRevision: 1, schemaProfile, fixtureEvidence: evidence, directEvidence: evidence });
 }
 function freeze(value) {
     if (typeof value === "object" && value !== null) {

package/dist/context.js

@@ -20,7 +20,7 @@ export function serializeContext(input, injectedSelection, onDiagnostics) {
         fail("Invalid tool capability selection.");
     if (selection.tools.state !== "enabled")
         fail(capabilityError(entry.publicId, selection.level, selection.tools));
-    const prepared = prepareToolContext(field(context, "tools") ?? [], isRecord(options) ? field(options, "toolChoice") : undefined);
+    const prepared = prepareToolContext(field(context, "tools") ?? [], isRecord(options) ? field(options, "toolChoice") : undefined, selection.tools.schemaProfile);
     const { tools: _tools, messages, ...textContext } = context;
     const { toolChoice: _choice, ...textOptions } = isRecord(options) ? options : {};
     const text = serializeTextContext({ ...input, context: { ...textContext, messages: [{ role: "user", content: "placeholder", timestamp: 0 }] }, options: textOptions });

package/dist/tool-context.d.ts

@@ -4,7 +4,7 @@ export interface PreparedToolContext {
     readonly mode: "AUTO" | "NONE";
 }
 export declare function hasToolContext(context: unknown): boolean;
-export declare function prepareToolContext(tools: unknown, choice: unknown): PreparedToolContext | undefined;
+export declare function prepareToolContext(tools: unknown, choice: unknown, schemaProfile: unknown): PreparedToolContext | undefined;
 type WirePart = object;
 type WireContent = {
     role: "user" | "model";

package/dist/tool-context.js

@@ -1,4 +1,5 @@
 import { canonicalJson, ToolPreflightError } from "./tool-contract.js";
+import { GEMINI_PARAMETERS_JSON_SCHEMA_PROFILE } from "./catalog.js";
 import { normalizeToolDeclarations } from "./tool-schema.js";
 export function hasToolContext(context) {
     if (!isRecord(context))
@@ -16,7 +17,9 @@ export function hasToolContext(context) {
         return Array.isArray(content) && content.some((part) => isRecord(part) && value(part, "type") === "toolCall");
     });
 }
-export function prepareToolContext(tools, choice) {
+export function prepareToolContext(tools, choice, schemaProfile) {
+    if (schemaProfile !== GEMINI_PARAMETERS_JSON_SCHEMA_PROFILE)
+        throw new ToolPreflightError("PI_TOOL_SCHEMA_PROFILE_UNSUPPORTED", "tools", "$");
     const declarations = normalizeToolDeclarations(tools ?? []);
     if (!declarations.length) {
         if (choice === "auto")

package/dist/tool-schema.js

@@ -1,10 +1,12 @@
-import { canonicalJson, denseArray, fail, freeze, ownData, plainObject } from "./tool-contract.js";
-const TYPES = new Set(["object", "array", "string", "number", "integer", "boolean"]);
-const KEYWORDS = new Set(["type", "description", "nullable", "enum", "const", "properties", "required", "items"]);
+import { denseArray, fail, freeze, ownData, plainObject } from "./tool-contract.js";
 const MAX_SCHEMA_DEPTH = 32;
 const MAX_SCHEMA_NODES = 2048;
 const MAX_SCHEMA_BYTES = 256 * 1024;
 const MAX_TOTAL_SCHEMA_BYTES = 1024 * 1024;
+const METADATA = new Set(["$schema", "$id", "$anchor", "$dynamicAnchor", "$vocabulary", "$comment"]);
+const SCHEMA_MAPS = new Set(["properties", "patternProperties", "dependentSchemas"]);
+const SCHEMAS = new Set(["additionalItems", "additionalProperties", "contains", "contentSchema", "else", "if", "items", "not", "propertyNames", "then", "unevaluatedItems", "unevaluatedProperties"]);
+const SCHEMA_ARRAYS = new Set(["allOf", "anyOf", "oneOf", "prefixItems"]);
 export function normalizeToolDeclarations(value) {
     const tools = denseArray(value, "tools", "$");
     const names = new Set();
@@ -32,94 +34,179 @@ function normalizeDeclaration(value, index, names) {
     const constrainedSampling = ownData(tool, "constrainedSampling", name, path);
     if (constrainedSampling !== undefined && constrainedSampling !== false)
         fail("PI_TOOL_CONSTRAINED_SAMPLING_UNSUPPORTED", name, `${path}.constrainedSampling`);
-    const parameterRoot = plainObject(ownData(tool, "parameters", name, path), name, "$");
-    if (ownData(parameterRoot, "type", name, "$") !== "object")
+    const root = plainObject(ownData(tool, "parameters", name, path), name, "$");
+    if (ownData(root, "type", name, "$") !== "object")
+        fail("PI_TOOL_SCHEMA_INVALID", name, "$.type");
+    const snapshot = snapshotJson(root, name, "$", { ancestors: new Set(), nodes: 0 });
+    if (!isJsonObject(snapshot))
+        fail("PI_TOOL_SCHEMA_INVALID", name, "$");
+    const parameters = emitSchema(snapshot, snapshot, name, "$", { nodes: 0 }, new Set());
+    if (!isJsonObject(parameters) || parameters.type !== "object")
         fail("PI_TOOL_SCHEMA_INVALID", name, "$.type");
-    const parameters = normalizeSchema(parameterRoot, name, "$");
     if (Buffer.byteLength(JSON.stringify(parameters), "utf8") > MAX_SCHEMA_BYTES)
         fail("PI_TOOL_SCHEMA_LIMIT", name, "$");
     return freeze({ name, description, parameters });
 }
-function normalizeSchema(value, declaration, path, state = { ancestors: new Set(), nodes: 0 }, depth = 0) {
+function snapshotJson(value, declaration, path, state, depth = 0) {
     if (depth > MAX_SCHEMA_DEPTH || ++state.nodes > MAX_SCHEMA_NODES)
         fail("PI_TOOL_SCHEMA_LIMIT", declaration, path);
-    if (typeof value === "object" && value !== null) {
-        if (state.ancestors.has(value))
-            fail("PI_TOOL_SCHEMA_INVALID", declaration, path);
-        state.ancestors.add(value);
+    if (value === null || typeof value === "string" || typeof value === "boolean")
+        return value;
+    if (typeof value === "number")
+        return Number.isFinite(value) ? value : fail("PI_TOOL_SCHEMA_INVALID", declaration, path);
+    if (typeof value !== "object" || state.ancestors.has(value))
+        fail("PI_TOOL_SCHEMA_INVALID", declaration, path);
+    state.ancestors.add(value);
+    try {
+        if (Array.isArray(value))
+            return freeze(snapshotArray(value, declaration, path, state, depth));
+        const object = plainObject(value, declaration, path);
+        const output = {};
+        for (const key of Object.keys(object).sort())
+            define(output, key, snapshotJson(ownData(object, key, declaration, path), declaration, pathSegment(path, key), state, depth + 1));
+        return freeze(output);
     }
-    const schema = plainObject(value, declaration, path);
-    for (const key of Object.keys(schema))
-        if (!KEYWORDS.has(key))
-            fail("PI_TOOL_SCHEMA_UNSUPPORTED", declaration, `${path}.${key}`);
-    const type = ownData(schema, "type", declaration, path);
-    if (typeof type !== "string" || !TYPES.has(type))
-        fail("PI_TOOL_SCHEMA_INVALID", declaration, `${path}.type`);
-    const output = { type };
-    const description = ownData(schema, "description", declaration, path);
-    if (description !== undefined) {
-        if (typeof description !== "string")
-            fail("PI_TOOL_SCHEMA_INVALID", declaration, `${path}.description`);
-        output.description = description;
+    finally {
+        state.ancestors.delete(value);
     }
-    const nullable = ownData(schema, "nullable", declaration, path);
-    if (nullable !== undefined) {
-        if (typeof nullable !== "boolean")
-            fail("PI_TOOL_SCHEMA_INVALID", declaration, `${path}.nullable`);
-        output.nullable = nullable;
+}
+function snapshotArray(value, declaration, path, state, depth) {
+    if (Object.getPrototypeOf(value) !== Array.prototype || Object.getOwnPropertySymbols(value).length || Object.getOwnPropertyNames(value).length !== value.length + 1)
+        fail("PI_TOOL_SCHEMA_INVALID", declaration, path);
+    const values = denseArray(value, declaration, path);
+    const output = [];
+    for (let index = 0; index < values.length; index += 1) {
+        const descriptor = Object.getOwnPropertyDescriptor(value, String(index));
+        if (!descriptor || !("value" in descriptor))
+            fail("PI_TOOL_SCHEMA_INVALID", declaration, `${path}[${index}]`);
+        output.push(snapshotJson(descriptor.value, declaration, `${path}[${index}]`, state, depth + 1));
     }
-    const enumValue = ownData(schema, "enum", declaration, path);
-    const constant = ownData(schema, "const", declaration, path);
-    if (enumValue !== undefined && constant !== undefined)
-        fail("PI_TOOL_SCHEMA_INVALID", declaration, `${path}.const`);
-    if (enumValue !== undefined)
-        output.enum = normalizeEnum(enumValue, type, nullable === true, declaration, `${path}.enum`);
-    if (constant !== undefined)
-        output.enum = freeze([validateEnumValue(constant, type, nullable === true, declaration, `${path}.const`)]);
-    if (type === "object")
-        normalizeObject(schema, output, declaration, path, state, depth);
-    else if (type === "array")
-        normalizeArray(schema, output, declaration, path, state, depth);
-    else if (ownData(schema, "properties", declaration, path) !== undefined || ownData(schema, "required", declaration, path) !== undefined || ownData(schema, "items", declaration, path) !== undefined)
+    return output;
+}
+function emitSchema(value, root, declaration, path, state, targets, depth = 0) {
+    if (depth > MAX_SCHEMA_DEPTH || ++state.nodes > MAX_SCHEMA_NODES)
+        fail("PI_TOOL_SCHEMA_LIMIT", declaration, path);
+    if (typeof value === "boolean")
+        return value;
+    if (!isJsonObject(value))
         fail("PI_TOOL_SCHEMA_INVALID", declaration, path);
-    return freeze(output);
+    const reference = value.$ref;
+    if (reference !== undefined) {
+        const referencePath = pathSegment(path, "$ref");
+        const target = resolveReference(reference, root, declaration, referencePath);
+        if (isJsonObject(target) && targets.has(target))
+            fail("PI_TOOL_SCHEMA_REFERENCE_CYCLE", declaration, referencePath);
+        const next = new Set(targets);
+        if (isJsonObject(target))
+            next.add(target);
+        const resolved = emitSchema(target, root, declaration, path, state, next, depth + 1);
+        const sibling = emitObject(value, root, declaration, path, state, targets, depth + 1, new Set(["$ref"]));
+        if (!Object.keys(sibling).length)
+            return resolved;
+        if (resolved === true || resolved === false)
+            return resolved === true ? sibling : false;
+        return freeze({ allOf: freeze([resolved, sibling]) });
+    }
+    return emitObject(value, root, declaration, path, state, targets, depth, new Set());
 }
-function normalizeObject(schema, output, declaration, path, state, depth) {
-    if (ownData(schema, "items", declaration, path) !== undefined)
-        fail("PI_TOOL_SCHEMA_INVALID", declaration, `${path}.items`);
-    const properties = plainObject(ownData(schema, "properties", declaration, path), declaration, `${path}.properties`);
-    const names = Object.keys(properties).sort();
-    if (!names.length)
-        fail("PI_TOOL_SCHEMA_INVALID", declaration, `${path}.properties`);
-    const normalized = {};
-    for (const name of names)
-        normalized[name] = normalizeSchema(properties[name], declaration, `${path}.properties.${name}`, state, depth + 1);
-    output.properties = freeze(normalized);
-    const required = ownData(schema, "required", declaration, path);
-    if (required !== undefined) {
-        const values = denseArray(required, declaration, `${path}.required`);
-        if (values.some((name) => typeof name !== "string" || !Object.hasOwn(properties, name)) || new Set(values).size !== values.length)
-            fail("PI_TOOL_SCHEMA_INVALID", declaration, `${path}.required`);
-        output.required = freeze([...values].sort());
+function emitObject(value, root, declaration, path, state, targets, depth, omitted) {
+    const output = {};
+    for (const key of Object.keys(value)) {
+        const child = value[key];
+        if (omitted.has(key) || METADATA.has(key))
+            continue;
+        if (key === "$defs" || key === "definitions") {
+            emitSchemaMap(child, root, declaration, pathSegment(path, key), state, targets, depth + 1);
+            continue;
+        }
+        if (SCHEMA_MAPS.has(key))
+            define(output, key, emitSchemaMap(child, root, declaration, pathSegment(path, key), state, targets, depth + 1));
+        else if (SCHEMA_ARRAYS.has(key))
+            define(output, key, emitSchemaArray(child, root, declaration, pathSegment(path, key), state, targets, depth + 1));
+        else if (key === "dependencies")
+            define(output, key, emitDependencies(child, root, declaration, pathSegment(path, key), state, targets, depth + 1));
+        else if (key === "items" && Array.isArray(child))
+            define(output, key, emitSchemaArray(child, root, declaration, pathSegment(path, key), state, targets, depth + 1));
+        else if (SCHEMAS.has(key))
+            define(output, key, emitSchema(child, root, declaration, pathSegment(path, key), state, targets, depth + 1));
+        else
+            define(output, key, child);
     }
+    return freeze(output);
 }
-function normalizeArray(schema, output, declaration, path, state, depth) {
-    if (ownData(schema, "properties", declaration, path) !== undefined || ownData(schema, "required", declaration, path) !== undefined)
+function emitSchemaMap(value, root, declaration, path, state, targets, depth) {
+    if (!isJsonObject(value))
         fail("PI_TOOL_SCHEMA_INVALID", declaration, path);
-    output.items = normalizeSchema(ownData(schema, "items", declaration, path), declaration, `${path}.items`, state, depth + 1);
+    const output = {};
+    for (const key of Object.keys(value))
+        define(output, key, emitSchema(value[key], root, declaration, pathSegment(path, key), state, targets, depth));
+    return freeze(output);
 }
-function normalizeEnum(value, type, nullable, declaration, path) {
-    const values = denseArray(value, declaration, path);
-    if (!values.length)
-        fail("PI_TOOL_SCHEMA_INVALID", declaration, path);
-    const normalized = values.map((item, index) => validateEnumValue(item, type, nullable, declaration, `${path}[${index}]`));
-    if (new Set(normalized.map((item) => JSON.stringify(item))).size !== normalized.length)
+function emitSchemaArray(value, root, declaration, path, state, targets, depth) {
+    if (!Array.isArray(value))
         fail("PI_TOOL_SCHEMA_INVALID", declaration, path);
-    return freeze(normalized);
+    return freeze(value.map((item, index) => emitSchema(item, root, declaration, `${path}[${index}]`, state, targets, depth)));
 }
-function validateEnumValue(value, type, nullable, declaration, path) {
-    const json = canonicalJson(value, declaration, path);
-    if (typeof json === "object" || (json === null && !nullable) || (json !== null && (type === "integer" ? typeof json !== "number" || !Number.isInteger(json) : typeof json !== type)))
+function emitDependencies(value, root, declaration, path, state, targets, depth) {
+    if (!isJsonObject(value))
         fail("PI_TOOL_SCHEMA_INVALID", declaration, path);
-    return json;
+    const output = {};
+    for (const key of Object.keys(value)) {
+        const dependency = value[key];
+        if (Array.isArray(dependency) && dependency.every((entry) => typeof entry === "string"))
+            define(output, key, dependency);
+        else
+            define(output, key, emitSchema(dependency, root, declaration, pathSegment(path, key), state, targets, depth));
+    }
+    return freeze(output);
+}
+function resolveReference(reference, root, declaration, path) {
+    if (typeof reference !== "string" || (reference !== "#" && !reference.startsWith("#/")))
+        fail("PI_TOOL_SCHEMA_REFERENCE_INVALID", declaration, path);
+    if (reference === "#")
+        return root;
+    let pointer;
+    try {
+        pointer = decodeURIComponent(reference.slice(1));
+    }
+    catch {
+        return fail("PI_TOOL_SCHEMA_REFERENCE_INVALID", declaration, path);
+    }
+    let current = root;
+    for (const rawToken of pointer.slice(1).split("/")) {
+        const token = decodeToken(rawToken, declaration, path);
+        if (Array.isArray(current)) {
+            if (!/^(0|[1-9][0-9]*)$/.test(token) || !Number.isSafeInteger(Number(token)) || Number(token) >= current.length)
+                fail("PI_TOOL_SCHEMA_REFERENCE_INVALID", declaration, path);
+            current = current[Number(token)];
+        }
+        else if (isJsonObject(current)) {
+            if (!Object.hasOwn(current, token))
+                fail("PI_TOOL_SCHEMA_REFERENCE_INVALID", declaration, path);
+            current = current[token];
+        }
+        else
+            fail("PI_TOOL_SCHEMA_REFERENCE_INVALID", declaration, path);
+    }
+    if (typeof current !== "boolean" && !isJsonObject(current))
+        fail("PI_TOOL_SCHEMA_REFERENCE_INVALID", declaration, path);
+    return current;
+}
+function decodeToken(value, declaration, path) {
+    return value.replace(/~(.)?/g, (escape, next) => {
+        if (escape === "~0")
+            return "~";
+        if (escape === "~1")
+            return "/";
+        return fail("PI_TOOL_SCHEMA_REFERENCE_INVALID", declaration, path);
+    });
+}
+function pathSegment(path, key) {
+    return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key) ? `${path}.${key}` : `${path}[${JSON.stringify(key)}]`;
+}
+function isJsonObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function define(target, key, value) {
+    Object.defineProperty(target, key, { value, enumerable: true, configurable: false, writable: false });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@benjamolina/pi-antigravity-guard",
-  "version": "0.4.1",
+  "version": "0.4.3",
   "description": "Pi adapter for Antigravity Guard",
   "type": "module",
   "license": "MIT",