feat(roads): add Turin 5T and Hong Kong TD real-time speed feeds

Both were wrongly written off as egress-blocked; on re-investigation both work:
- turin-5t-flow (turin-fdt-xml): 5T FDT feed, self-contained inline WGS84
  points + speedflow speed; the earlier 403 was HTTP-only (HTTPS serves fine).
  Keyless, CC-BY-4.0. Enabled. ~99 flows live.
- hk-td-flow (hk-raw-xml + hk-detector-csv registry): TD raw detector
  speed/volume joined to the detector-locations CSV (WGS84) by detector_id;
  representative speed = volume-weighted mean of valid lanes. The blocked
  segment-geometry file was the wrong path — the detector-level data resolves
  cleanly. Keyless, new HK-Gov-Open-Data license. Enabled. ~725 flows live.

Adds turin-fdt-xml + hk-raw-xml formats, hk-detector-csv station registry, and
the HK-Gov-Open-Data license.

Author: Medformatik

packages/core/src/model.ts

@@ -45,6 +45,8 @@ export type SourceFormat =
   | "madrid-informo-xml"
   | "lta-speedbands-json"
   | "miv-xml"
+  | "turin-fdt-xml"
+  | "hk-raw-xml"
   | "gtfs-rt"
   | "native"
   | "crowd";

packages/ingest-framework/src/licenses.ts

@@ -138,6 +138,14 @@ export const LICENSES: Record<string, LicenseInfo> = Object.fromEntries([
     shareAlike: false,
     commercialOk: true,
   }),
+  L({
+    id: "HK-Gov-Open-Data",
+    name: "DATA.GOV.HK Terms and Conditions of Use",
+    url: "https://data.gov.hk/en/terms-and-conditions",
+    attributionRequired: true,
+    shareAlike: false,
+    commercialOk: true,
+  }),
   L({
     id: "NYC-Open-Data",
     name: "NYC Open Data Terms of Use",

packages/roads/feeds/roads/hk.json5

@@ -0,0 +1,21 @@
+[
+  {
+    id: "hk-td-flow",
+    name: "Transport Department traffic detectors (Hong Kong)",
+    format: "hk-raw-xml",
+    produces: "flow",
+    url: "https://resource.data.one.gov.hk/td/traffic-detectors/rawSpeedVol-all.xml",
+    stationRegistry: {
+      url: "https://static.data.gov.hk/td/traffic-data-strategic-major-roads/info/traffic_speed_volume_occ_info.csv",
+      format: "hk-detector-csv",
+    },
+    cadenceSec: 120,
+    freshnessWindowSec: 600,
+    license: "HK-Gov-Open-Data",
+    licenseUrl: "https://data.gov.hk/en/terms-and-conditions",
+    attribution: "Transport Department, HKSAR",
+    country: "HK",
+    privacyUrl: "https://www.td.gov.hk/en/privacy_policy/index.html",
+    enabledByDefault: true,
+  },
+]

packages/roads/feeds/roads/it.json5

@@ -0,0 +1,17 @@
+[
+  {
+    id: "turin-5t-flow",
+    name: "5T real-time traffic flow (Turin)",
+    format: "turin-fdt-xml",
+    produces: "flow",
+    url: "https://opendata.5t.torino.it/get_fdt",
+    cadenceSec: 300,
+    freshnessWindowSec: 900,
+    license: "CC-BY-4.0",
+    licenseUrl: "https://creativecommons.org/licenses/by/4.0/",
+    attribution: "5T / Città di Torino",
+    country: "IT",
+    privacyUrl: "https://www.5t.torino.it/privacy/",
+    enabledByDefault: true,
+  },
+]

packages/roads/src/__tests__/feeds.test.ts

@@ -432,8 +432,8 @@ describe("FEED_SOURCES", () => {
     expect(new Set(ids).size).toBe(ids.length);
   });
 
-  it("loads every feed from the data files (all 60 migrated)", () => {
-    expect(FEED_SOURCES.length).toBe(60);
+  it("loads every feed from the data files (all 62 migrated)", () => {
+    expect(FEED_SOURCES.length).toBe(62);
     expect(new Set(FEED_SOURCES.map((f) => f.id)).size).toBe(FEED_SOURCES.length);
   });
 

packages/roads/src/__tests__/flow-turin.test.ts

@@ -0,0 +1,33 @@
+import { describe, expect, it } from "vitest";
+import { parseTurinFlow } from "../flow-turin.js";
+import type { SourceDescriptor } from "../types.js";
+
+const src = {
+  id: "turin-5t-flow",
+  attribution: "5T / Città di Torino",
+  country: "IT",
+  license: "CC-BY-4.0",
+} as SourceDescriptor;
+
+const XML = `<?xml version="1.0" encoding="utf-8"?>
+<traffic_data xmlns="https://simone.5t.torino.it/ns/traffic_data.xsd" generation_time="2026-07-10T18:00:03.516Z">
+  <FDT_data lcd1="39983" Road_name="Corso Allamano(TO)" direction="positive" lat="45.0507" lng="7.6225" accuracy="95" period="5"><speedflow flow="360" speed="54.5"/></FDT_data>
+  <FDT_data lcd1="40121" Road_name="Corso Regina Margherita(TO)" direction="positive" lat="45.096231" lng="7.625643" accuracy="0" period="5"><speedflow flow="0" speed="0"/></FDT_data>
+</traffic_data>`;
+
+describe("parseTurinFlow", () => {
+  it("emits an inline-Point flow with km/h speed and drops accuracy=0 detectors", () => {
+    const { flows } = parseTurinFlow(XML, src);
+    expect(flows).toHaveLength(1);
+    expect(flows[0]!.id).toBe("turin-5t-flow:39983");
+    expect(flows[0]!.sourceFormat).toBe("turin-fdt-xml");
+    expect(flows[0]!.speedKph).toBe(54.5);
+    expect(flows[0]!.direction).toBe("positive");
+    expect(flows[0]!.geometry).toEqual({ type: "Point", coordinates: [7.6225, 45.0507] });
+    expect(flows[0]!.dataUpdatedAt).toBe("2026-07-10T18:00:03.516Z");
+  });
+
+  it("flags a hard parse failure", () => {
+    expect(parseTurinFlow("not xml <", src).failed).toBe(true);
+  });
+});

packages/roads/src/__tests__/hk.test.ts

@@ -0,0 +1,61 @@
+import { describe, expect, it } from "vitest";
+import { parseHkDetectors, parseHkRawFlow } from "../hk.js";
+import type { SourceDescriptor } from "../types.js";
+
+const src = {
+  id: "hk-td-flow",
+  attribution: "Transport Department, HKSAR",
+  country: "HK",
+  license: "HK-Gov-Open-Data",
+} as SourceDescriptor;
+
+// Leading  mirrors the live file's UTF-8 BOM.
+const CSV = `AID_ID_Number,District,Road_EN,Road_TC,Road_SC,Easting,Northing,Latitude,Longitude,Direction,Rotation
+AID01101,Southern,Aberdeen Praya Road,x,x,833758,812147,22.248091,114.152525,South East,100
+BADLAT,Southern,Road,x,x,0,0,0,0,North,0
+`;
+
+const XML = `<?xml version="1.0" encoding="utf-8"?>
+<raw_speed_volume_list><periods>
+  <period><period_from>01:50:00</period_from><period_to>01:50:30</period_to><detectors>
+    <detector><detector_id>AID01101</detector_id><lanes>
+      <lane><lane_id>Fast Lane</lane_id><speed>60</speed><volume>1</volume><valid>Y</valid></lane>
+    </lanes></detector>
+  </detectors></period>
+  <period><period_from>01:55:00</period_from><period_to>01:55:30</period_to><detectors>
+    <detector><detector_id>AID01101</detector_id><lanes>
+      <lane><lane_id>Fast Lane</lane_id><speed>100</speed><volume>3</volume><valid>Y</valid></lane>
+      <lane><lane_id>Slow Lane</lane_id><speed>60</speed><volume>1</volume><valid>Y</valid></lane>
+      <lane><lane_id>Broken</lane_id><speed>0</speed><volume>0</volume><valid>N</valid></lane>
+    </lanes></detector>
+  </detectors></period>
+</periods></raw_speed_volume_list>`;
+
+describe("parseHkDetectors", () => {
+  it("maps AID id → WGS84 Point, strips the BOM, and drops out-of-bounds rows", () => {
+    const map = parseHkDetectors(CSV);
+    expect(map.size).toBe(1);
+    expect(map.get("AID01101")).toEqual({ type: "Point", coordinates: [114.152525, 22.248091] });
+  });
+});
+
+describe("parseHkRawFlow", () => {
+  it("uses the latest period and the volume-weighted mean of valid lanes", () => {
+    const siteMap = parseHkDetectors(CSV);
+    const { flows } = parseHkRawFlow(XML, src, siteMap);
+    expect(flows).toHaveLength(1);
+    expect(flows[0]!.id).toBe("hk-td-flow:AID01101");
+    // Latest period: (100·3 + 60·1) / (3+1) = 90; the valid=N lane is ignored.
+    expect(flows[0]!.speedKph).toBe(90);
+    expect(flows[0]!.geometry).toEqual({ type: "Point", coordinates: [114.152525, 22.248091] });
+    expect(flows[0]!.dataUpdatedAt).toBe("01:55:30");
+  });
+
+  it("skips detectors with no geometry", () => {
+    expect(parseHkRawFlow(XML, src, new Map()).flows).toHaveLength(0);
+  });
+
+  it("flags a hard parse failure", () => {
+    expect(parseHkRawFlow("nope <", src, new Map()).failed).toBe(true);
+  });
+});

packages/roads/src/feed-schema.ts

@@ -44,6 +44,7 @@ export const roadFeedSchema = z
           "webtris-sites",
           "miv-config",
           "france-comptage-csv",
+          "hk-detector-csv",
         ]),
       })
       .strict()

packages/roads/src/feeds.ts

@@ -28,6 +28,8 @@ import { parseBonnFlow } from "./flow-bonn.js";
 import { parseMadridFlow } from "./flow-madrid.js";
 import { parseLtaSpeedBands } from "./flow-lta-speedbands.js";
 import { parseMivFlow } from "./miv.js";
+import { parseTurinFlow } from "./flow-turin.js";
+import { parseHkRawFlow } from "./hk.js";
 import type { SourceDescriptor } from "./types.js";
 
 // FeedAuth now lives in @openconditions/ingest-framework; re-exported here so
@@ -63,7 +65,12 @@ export type FeedSource = FeedSourceBase & {
    */
   stationRegistry?: {
     url: string;
-    format: "fintraffic-stations" | "webtris-sites" | "miv-config" | "france-comptage-csv";
+    format:
+      | "fintraffic-stations"
+      | "webtris-sites"
+      | "miv-config"
+      | "france-comptage-csv"
+      | "hk-detector-csv";
   };
   /** Field mapping for `format: "geojson"` feeds (passed to the generic reader). */
   geojson?: GeoJsonMapping;
@@ -157,6 +164,8 @@ export function flowParserFor(format: SourceFormat): FlowParserFn {
   if (format === "madrid-informo-xml") return parseMadridFlow;
   if (format === "lta-speedbands-json") return parseLtaSpeedBands;
   if (format === "miv-xml") return parseMivFlow;
+  if (format === "turin-fdt-xml") return parseTurinFlow;
+  if (format === "hk-raw-xml") return parseHkRawFlow;
   throw new Error(`No flow parser registered for format: ${format}`);
 }
 

packages/roads/src/flow-turin.ts

@@ -0,0 +1,87 @@
+import type { Point } from "geojson";
+import type { RoadFlow } from "./model.js";
+import type { SourceDescriptor } from "./types.js";
+import { makeOrigin } from "./flow.js";
+import type { FlowParseResult } from "./flow.js";
+import { getXmlChild, getXmlChildren, isXmlObject, parseXmlDocument, xmlText } from "./xml.js";
+
+const ABSURD_SPEED_KPH = 250;
+
+function num(raw: unknown): number | undefined {
+  if (raw == null || raw === "") return undefined;
+  const n = Number(raw);
+  return Number.isFinite(n) ? n : undefined;
+}
+
+/**
+ * Parse the Turin 5T real-time traffic-flow feed (`opendata.5t.torino.it/get_fdt`)
+ * into RoadFlow point measurements. Each `<FDT_data>` is a detector carrying
+ * inline WGS84 `lat`/`lng`, an `accuracy` confidence, and a child
+ * `<speedflow speed=.. flow=..>` (speed in km/h). Detectors with no confidence
+ * (`accuracy=0`, published with a placeholder `speed=0`) or no coordinate are
+ * skipped. los is left "unknown" for baseline enrichment.
+ */
+export function parseTurinFlow(input: string | Buffer, src: SourceDescriptor): FlowParseResult {
+  let doc: ReturnType<typeof parseXmlDocument>;
+  try {
+    doc = parseXmlDocument(input, {
+      removeNSPrefix: true,
+      ignoreAttributes: false,
+      isArray: (n) => n === "FDT_data",
+    });
+  } catch {
+    return { flows: [], events: [], failed: true };
+  }
+  const root = isXmlObject(doc) ? (getXmlChild(doc, "traffic_data") ?? doc) : null;
+  if (!root) return { flows: [], events: [], failed: true };
+
+  const detectors = getXmlChildren(root, "FDT_data");
+  const genTime = xmlText(root["@_generation_time"]);
+  const now = new Date().toISOString();
+  const origin = makeOrigin(src);
+  const flows: RoadFlow[] = [];
+
+  for (const fdt of detectors) {
+    try {
+      const id = xmlText(fdt["@_lcd1"]);
+      if (!id) continue;
+      const accuracy = num(xmlText(fdt["@_accuracy"]));
+      if (accuracy == null || accuracy <= 0) continue; // no confident measurement this cycle
+      const lon = num(xmlText(fdt["@_lng"]));
+      const lat = num(xmlText(fdt["@_lat"]));
+      if (lon == null || lat == null) continue;
+
+      const sf = getXmlChild(fdt, "speedflow");
+      const speedKph = num(xmlText(sf?.["@_speed"]));
+      if (speedKph == null || speedKph < 0 || speedKph >= ABSURD_SPEED_KPH) continue;
+
+      const geometry: Point = { type: "Point", coordinates: [lon, lat] };
+      const direction = xmlText(fdt["@_direction"]);
+      flows.push({
+        id: `${src.id}:${id}`,
+        source: src.id,
+        sourceFormat: "turin-fdt-xml",
+        domain: "roads",
+        kind: "measurement",
+        metric: "flow",
+        value: speedKph,
+        unit: "km/h",
+        level: "unknown",
+        aggregation: "live",
+        status: "active",
+        geometry,
+        los: "unknown",
+        speedKph,
+        ...(direction ? { direction } : {}),
+        origin,
+        dataUpdatedAt: genTime ?? now,
+        fetchedAt: now,
+        isStale: false,
+      });
+    } catch (err) {
+      console.warn("[turin-flow] skipped malformed FDT_data:", err);
+    }
+  }
+
+  return { flows, events: [] };
+}