Files
reverse-engineering-anything/src/domain/javascript/staticObservedEndpointSchemas.ts
T
morluto 62d6cfac92 refactor(domain): name known coverage once and derive local coverage enums from it (#11428)
* refactor(domain): name known coverage once and derive six native coverage enums from it

knownCoverageStatusSchema in src/domain/coverage.ts replaces the four per-domain coverageStatusSchema.exclude(["unknown"]) copies (Android, Flutter, GPU, model) and six plain ["complete", "partial"] enums in native reports (Apple IPS, PE certificates and imports, Windows shortcuts, native call observation, NativeAOT metadata recovery). Advertised schemas are unchanged. local-completeness-enum: 91 -> 85.

* refactor(domain): use the shared known coverage schema for ADB device analysis

* refactor(domain): derive pcap, firmware, Apktool, JEB and WASM interface coverage from known coverage (#11430)

Each producer decides coverage from what it examined (dissected-field gaps, unpublished firmware entries, string-table facts, a short JEB unit page, a WABT budget stop), so none reports unknown. Advertised schemas are unchanged. local-completeness-enum: 85 -> 79.

* refactor(domain): derive eleven checked coverage enums from known coverage (#11438)

* refactor(domain): derive eleven checked coverage enums from known coverage

* refactor(domain): derive coverage-plus-outcome enums from the coverage owner (#11440)
2026-11-16 04:15:59 +08:00

105 lines
3.7 KiB
TypeScript

import { z } from "zod";
import { coverageStatusSchema } from "../coverage.js";
import { digestSchema, prefixedDigestSchema } from "../digests.js";
import { ROUTE_RULES } from "../analysisView/webNetworkRouteTemplates.js";
export const comparedStaticEndpointSchema = z.strictObject({
endpoint_id: prefixedDigestSchema("static_endpoint"),
node_id: prefixedDigestSchema("jag_node"),
observation_id: prefixedDigestSchema("jag_observation"),
method: z.string().nullable(),
method_basis: z.enum(["api-definition", "callee-spelling", "unknown"]),
origin: z.string().nullable(),
origin_basis: z.enum(["literal-url", "caller-origin", "unknown"]),
path: z.string().nullable(),
status: z.enum(["matched", "not-observed-in-capture", "unknown"]),
reason: z
.enum([
"candidate-endpoint",
"unconfirmed-static-observation",
"partial-target",
"non-http-target",
"unresolved-target",
"unparseable-target",
"normalization-required",
"origin-required",
"ambiguous-method",
"capture-incomplete",
"origin-not-exercised",
"no-observed-match",
])
.nullable(),
});
export const comparedObservedGroupSchema = z.strictObject({
group_id: prefixedDigestSchema("observed_endpoint"),
method: z.string(),
origin: z.string(),
path_template: z.string(),
templated_segments: z.array(
z.strictObject({
segment_index: z.int().nonnegative(),
rule: z.enum(ROUTE_RULES),
}),
),
record_ordinals: z.array(z.int().nonnegative()),
status: z.enum(["matched", "unknown", "observed-without-static-match"]),
reason: z.literal("ambiguous-static-method").nullable(),
});
export const endpointMatchSchema = z.strictObject({
match_id: prefixedDigestSchema("endpoint_match"),
endpoint_id: comparedStaticEndpointSchema.shape.endpoint_id,
group_id: comparedObservedGroupSchema.shape.group_id,
basis: z.enum(["exact", "template-compatible"]),
supporting_record_ordinal: z.int().nonnegative(),
});
export const staticObservedEndpointComparisonSchema = z.strictObject({
comparison_id: prefixedDigestSchema("endpoint_comparison"),
application: z.strictObject({
evidence_id: prefixedDigestSchema("ev"),
graph_id: prefixedDigestSchema("jag"),
}),
capture: z.strictObject({
evidence_id: prefixedDigestSchema("ev"),
artifact: z.strictObject({
path: z.string(),
sha256: digestSchema.nullable(),
}),
}),
declared_origin: z.string().nullable(),
summary: z.strictObject({
static_network_endpoint_observations: z.int().nonnegative(),
matched: z.int().nonnegative(),
not_observed_in_capture: z.int().nonnegative(),
unknown: z.int().nonnegative(),
observed_groups: z.int().nonnegative(),
observed_without_static_match: z.int().nonnegative(),
observed_unknown: z.int().nonnegative(),
matches: z.int().nonnegative(),
}),
source_coverage: z.strictObject({
application: z.strictObject({
status: z.enum([...coverageStatusSchema.options, "unavailable"]),
truncated: z.boolean(),
omitted_count: z.int().nonnegative().nullable(),
limit_count: z.int().nonnegative(),
limitation_count: z.int().nonnegative(),
}),
capture_limitation_count: z.int().nonnegative(),
observed_records_examined: z.int().nonnegative(),
observed_records_total: z.int().nonnegative(),
observed_records_excluded: z.int().nonnegative(),
}),
static_endpoints: z.array(comparedStaticEndpointSchema),
observed_groups: z.array(comparedObservedGroupSchema),
matches: z.array(endpointMatchSchema),
evidence_links: z.array(prefixedDigestSchema("ev")),
limitations: z.array(z.string()),
});
export type StaticObservedEndpointComparison = z.output<
typeof staticObservedEndpointComparisonSchema
>;